aiagents4pharma 1.10.0__py3-none-any.whl → 1.12.0__py3-none-any.whl

aiagents4pharma/talk2biomodels/agents/t2b_agent.py

@@ -16,6 +16,7 @@ from ..tools.get_modelinfo import GetModelInfoTool
 from ..tools.simulate_model import SimulateModelTool
 from ..tools.custom_plotter import CustomPlotterTool
 from ..tools.ask_question import AskQuestionTool
+from ..tools.parameter_scan import ParameterScanTool
 from ..states.state_talk2biomodels import Talk2Biomodels
 
 # Initialize logger
@@ -35,17 +36,13 @@ def get_app(uniq_id, llm_model='gpt-4o-mini'):
         return response
 
     # Define the tools
-    simulate_model = SimulateModelTool()
-    custom_plotter = CustomPlotterTool()
-    ask_question = AskQuestionTool()
-    search_model = SearchModelsTool()
-    get_modelinfo = GetModelInfoTool()
     tools = ToolNode([
-                    simulate_model,
-                    ask_question,
-                    custom_plotter,
-                    search_model,
-                    get_modelinfo
+                    SimulateModelTool(),
+                    AskQuestionTool(),
+                    CustomPlotterTool(),
+                    SearchModelsTool(),
+                    GetModelInfoTool(),
+                    ParameterScanTool()
                     ])
 
     # Define the model

aiagents4pharma/talk2biomodels/models/basico_model.py

@@ -48,52 +48,49 @@ class BasicoModel(SysBioModel):
             self.name = basico.model_info.get_model_name(model=self.copasi_model)
         return self
 
-    def simulate(self,
-                 parameters: Optional[Dict[str, Union[float, int]]] = None,
-                 duration: Union[int, float] = 10,
-                 interval: int = 10
-                 ) -> pd.DataFrame:
+    def update_parameters(self, parameters: Dict[str, Union[float, int]]) -> None:
+        """
+        Update model parameters with new values.
+        """
+        # Update parameters in the model
+        for param_name, param_value in parameters.items():
+            # check if the param_name is not None
+            if param_name is None:
+                continue
+            # if param is a kinetic parameter
+            df_all_params = basico.model_info.get_parameters(model=self.copasi_model)
+            if param_name in df_all_params.index.tolist():
+                basico.model_info.set_parameters(name=param_name,
+                                            exact=True,
+                                            initial_value=param_value,
+                                            model=self.copasi_model)
+            # if param is a species
+            else:
+                basico.model_info.set_species(name=param_name,
+                                            exact=True,
+                                            initial_concentration=param_value,
+                                            model=self.copasi_model)
+
+    def simulate(self, 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
-                # if param is a kinectic parameter
-                df_all_params = basico.model_info.get_parameters(model=self.copasi_model)
-                if param_name in df_all_params.index.tolist():
-                    basico.model_info.set_parameters(name=param_name,
-                                                exact=True,
-                                                initial_value=param_value,
-                                                model=self.copasi_model)
-                # if param is a species
-                else:
-                    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)
-        # 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)
+        # # 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

aiagents4pharma/talk2biomodels/models/sys_bio_model.py

@@ -35,18 +35,21 @@ class SysBioModel(ABC, BaseModel):
         Returns:
             dict: Dictionary with model metadata
         """
+    @abstractmethod
+    def update_parameters(self, parameters: Dict[str, Union[float, int]]) -> None:
+        """
+        Abstract method to update model parameters.
+
+        Args:
+            parameters: Dictionary of parameter values.
+        """
 
     @abstractmethod
-    def simulate(self,
-                 parameters: Dict[str, Union[float, int]],
-                 duration: Union[int, float]) -> List[float]:
+    def simulate(self, 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:

aiagents4pharma/talk2biomodels/states/state_talk2biomodels.py

@@ -12,13 +12,13 @@ class Talk2Biomodels(AgentState):
     """
     The state for the Talk2BioModels agent.
     """
-    model_id: Annotated[list, operator.add]
-    # sbml_file_path: str
+    llm_model: str
     # A StateGraph may receive a concurrent updates
     # which is not supported by the StateGraph.
     # Therefore, we need to use Annotated to specify
     # the operator for the sbml_file_path field.
     # https://langchain-ai.github.io/langgraph/troubleshooting/errors/INVALID_CONCURRENT_GRAPH_UPDATE/
+    model_id: Annotated[list, operator.add]
     sbml_file_path: Annotated[list, operator.add]
     dic_simulated_data: Annotated[list[dict], operator.add]
-    llm_model: str
+    dic_scanned_data: Annotated[list[dict], operator.add]

aiagents4pharma/talk2biomodels/tests/test_basico_model.py

@@ -19,13 +19,14 @@ def test_with_biomodel_id(model):
     Test initialization of BasicoModel with biomodel_id.
     """
     assert model.biomodel_id == 64
+    model.update_parameters(parameters={'Pyruvate': 0.5, 'KmPFKF6P': 1.5})
+    df_species = basico.model_info.get_species(model=model.copasi_model)
+    assert df_species.loc['Pyruvate', 'initial_concentration'] == 0.5
+    df_parameters = basico.model_info.get_parameters(model=model.copasi_model)
+    assert df_parameters.loc['KmPFKF6P', 'initial_value'] == 1.5
     # check if the simulation results are a pandas DataFrame object
-    assert isinstance(model.simulate(parameters={'Pyruvate': 0.5, 'KmPFKF6P': 1.5},
-                                     duration=2,
-                                     interval=2),
-                    pd.DataFrame)
-    assert isinstance(model.simulate(parameters={None: None}, duration=2, interval=2),
-                    pd.DataFrame)
+    assert isinstance(model.simulate(duration=2, interval=2), pd.DataFrame)
+    model.update_parameters(parameters={None: None})
     assert model.description == basico.biomodels.get_model_info(model.biomodel_id)["description"]
 
 def test_with_sbml_file():
@@ -35,8 +36,6 @@ def test_with_sbml_file():
     model_object = BasicoModel(sbml_file_path="./BIOMD0000000064_url.xml")
     assert model_object.sbml_file_path == "./BIOMD0000000064_url.xml"
     assert isinstance(model_object.simulate(duration=2, interval=2), pd.DataFrame)
-    assert isinstance(model_object.simulate(parameters={'NADH': 0.5}, duration=2, interval=2),
-                      pd.DataFrame)
 
 def test_check_biomodel_id_or_sbml_file_path():
     '''

aiagents4pharma/talk2biomodels/tests/test_langgraph.py

@@ -119,6 +119,68 @@ def test_simulate_model_tool():
     # Check if the data of the second model contains
     assert 'mTORC2' in dic_simulated_data[1]['data']
 
+def test_param_scan_tool():
+    '''
+    In this test, we will test the parameter_scan tool.
+    We will prompt it to scan the parameter `kIL6RBind`
+    from 1 to 100 in steps of 10, record the changes
+    in the concentration of the species `Ab{serum}` in
+    model 537.
+
+    We will pass the inaccuarate parameter (`KIL6Rbind`)
+    and species names (just `Ab`) to the tool to test
+    if it can deal with it.
+
+    We expect the agent to first invoke the parameter_scan
+    tool and raise an error. It will then invoke another
+    tool get_modelinfo to get the correct parameter
+    and species names. Finally, the agent will reinvoke
+    the parameter_scan tool with the correct parameter
+    and species names.
+
+    '''
+    unique_id = 123
+    app = get_app(unique_id)
+    config = {"configurable": {"thread_id": unique_id}}
+    app.update_state(config, {"llm_model": "gpt-4o-mini"})
+    prompt = """How will the value of Ab in model 537 change
+            if the param kIL6Rbind is varied from 1 to 100 in steps of 10?
+            Set the initial `DoseQ2W` concentration to 300.
+            Reset the IL6{serum} concentration to 100 every 500 hours.
+            Assume that the model is simulated for 2016 hours with
+            an interval of 2016."""
+    # Invoke the agent
+    app.invoke(
+        {"messages": [HumanMessage(content=prompt)]},
+        config=config
+    )
+    current_state = app.get_state(config)
+    reversed_messages = current_state.values["messages"][::-1]
+    # Loop through the reversed messages until a
+    # ToolMessage is found.
+    df = pd.DataFrame(columns=['name', 'status', 'content'])
+    names = []
+    statuses = []
+    contents = []
+    for msg in reversed_messages:
+        # Assert that the message is a ToolMessage
+        # and its status is "error"
+        if not isinstance(msg, ToolMessage):
+            continue
+        names.append(msg.name)
+        statuses.append(msg.status)
+        contents.append(msg.content)
+    df = pd.DataFrame({'name': names, 'status': statuses, 'content': contents})
+    # print (df)
+    assert any((df["status"] == "error") &
+               (df["name"] == "parameter_scan") &
+               (df["content"].str.startswith("Error: ValueError('Invalid parameter name:")))
+    assert any((df["status"] == "success") &
+               (df["name"] == "parameter_scan") &
+               (df["content"].str.startswith("Parameter scan results of")))
+    assert any((df["status"] == "success") &
+               (df["name"] == "get_modelinfo"))
+
 def test_integration():
     '''
     Test the integration of the tools.
@@ -184,9 +246,9 @@ def test_integration():
     reversed_messages = current_state.values["messages"][::-1]
     # Loop through the reversed messages
     # until a ToolMessage is found.
-    expected_header = ['Time', 'CRP[serum]', 'CRPExtracellular']
+    expected_header = ['Time', 'CRP{serum}', 'CRPExtracellular']
     expected_header += ['CRP Suppression (%)', 'CRP (% of baseline)']
-    expected_header += ['CRP[liver]']
+    expected_header += ['CRP{liver}']
     predicted_artifact = []
     for msg in reversed_messages:
         if isinstance(msg, ToolMessage):

aiagents4pharma/talk2biomodels/tests/test_sys_bio_model.py

@@ -16,6 +16,8 @@ class TestBioModel(SysBioModel):
     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")
+    param1: Optional[float] = Field(0.0, description="Parameter 1")
+    param2: Optional[float] = Field(0.0, description="Parameter 2")
 
     def get_model_metadata(self) -> Dict[str, Union[str, int]]:
         '''
@@ -23,15 +25,18 @@ class TestBioModel(SysBioModel):
         '''
         return self.biomodel_id
 
-    def simulate(self,
-                 parameters: Dict[str, Union[float, int]],
-                 duration: Union[int, float]) -> List[float]:
+    def update_parameters(self, parameters):
+        '''
+        Update the model parameters.
+        '''
+        self.param1 = parameters.get('param1', 0.0)
+        self.param2 = parameters.get('param2', 0.0)
+
+    def simulate(self, duration: Union[int, float]) -> List[float]:
         '''
         Simulate the model.
         '''
-        param1 = parameters.get('param1', 0.0)
-        param2 = parameters.get('param2', 0.0)
-        return [param1 + param2 * t for t in range(int(duration))]
+        return [self.param1 + self.param2 * t for t in range(int(duration))]
 
 def test_get_model_metadata():
     '''
@@ -53,5 +58,6 @@ def test_simulate():
     Test the simulate method of the BioModel class.
     '''
     model = TestBioModel(biomodel_id=123, name="Test Model", description="A test model")
-    results = model.simulate(parameters={'param1': 1.0, 'param2': 2.0}, duration=4.0)
+    model.update_parameters({'param1': 1.0, 'param2': 2.0})
+    results = model.simulate(duration=4.0)
     assert results == [1.0, 3.0, 5.0, 7.0]

aiagents4pharma/talk2biomodels/tools/__init__.py

@@ -6,4 +6,5 @@ from . import simulate_model
 from . import ask_question
 from . import custom_plotter
 from . import get_modelinfo
+from . import parameter_scan
 from . import load_biomodel

aiagents4pharma/talk2biomodels/tools/get_modelinfo.py

@@ -47,8 +47,10 @@ class GetModelInfoTool(BaseTool):
     """
     This tool ise used extract model information.
     """
-    name: str = "get_parameters"
-    description: str = "A tool for extracting model information."
+    name: str = "get_modelinfo"
+    description: str = """A tool for extracting name,
+                    description, species, parameters,
+                    compartments, and units from a model."""
     args_schema: Type[BaseModel] = GetModelInfoInput
 
     def _run(self,
@@ -81,7 +83,7 @@ class GetModelInfoTool(BaseTool):
         # 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'] = df_species['display_name'].tolist()
             dic_results['Species'] = ','.join(dic_results['Species'])
 
         # Extract parameters from the model

aiagents4pharma/talk2biomodels/tools/parameter_scan.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+
+"""
+Tool for parameter scan.
+"""
+
+import logging
+from dataclasses import dataclass
+from typing import Type, Union, List, Annotated
+import pandas as pd
+import basico
+from pydantic import BaseModel, Field
+from langgraph.types import Command
+from langgraph.prebuilt import InjectedState
+from langchain_core.tools import BaseTool
+from langchain_core.messages import ToolMessage
+from langchain_core.tools.base import InjectedToolCallId
+from .load_biomodel import ModelData, load_biomodel
+
+# Initialize logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@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] = Field(description="species name", default=[])
+    species_concentration: List[Union[int, float]] = Field(
+        description="initial species concentration",
+        default=[])
+
+@dataclass
+class TimeSpeciesNameConcentration:
+    """
+    Dataclass for storing the time, species name, and concentration data.
+    """
+    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 ReocurringData:
+    """
+    Dataclass for species that reoccur. In other words, the concentration
+    of the species resets to a certain value after a certain time interval.
+    """
+    data: List[TimeSpeciesNameConcentration] = Field(
+        description="time, name, and concentration data of species that reoccur",
+        default=[])
+
+@dataclass
+class ParameterScanData(BaseModel):
+    """
+    Dataclass for storing the parameter scan data.
+    """
+    species_names: List[str] = Field(description="species names to scan",
+                              default=[])
+    parameter_name: str = Field(description="Parameter name to scan",
+                                 default_factory=None)
+    parameter_values: List[Union[int, float]] = Field(
+        description="Parameter values to scan",
+        default_factory=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)
+    reocurring_data: ReocurringData = Field(
+        description="""Concentration and time data of species that reoccur
+            For example, a species whose concentration resets to a certain value
+            after a certain time interval""")
+    parameter_scan_data: ParameterScanData = Field(
+        description="parameter scan data",
+        default=None)
+    scan_name: str = Field(
+        description="""An AI assigned `_` separated name of
+        the parameter scan experiment based on human query""")
+
+def add_rec_events(model_object, reocurring_data):
+    """
+    Add reocurring events to the model.
+    """
+    for row in reocurring_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)
+
+def make_list_dic_scanned_data(dic_param_scan, arg_data, sys_bio_model, tool_call_id):
+    """
+    Prepare the list dictionary of scanned data
+    that will be passed to the state of the graph.
+
+    Args:
+        dic_param_scan: Dictionary of parameter scan results.
+        arg_data: The argument data.
+        sys_bio_model: The model data.
+        tool_call_id: The tool call ID.
+
+    Returns:
+        list: List of dictionary of scanned data.
+    """
+    list_dic_scanned_data = []
+    for species_name, df_param_scan in dic_param_scan.items():
+        logger.log(logging.INFO, "Parameter scan results for %s with shape %s",
+                    species_name,
+                    df_param_scan.shape)
+        # Prepare the list dictionary of scanned data
+        # that will be passed to the state of the graph
+        list_dic_scanned_data.append({
+            'name': arg_data.scan_name+':'+species_name,
+            'source': sys_bio_model.biomodel_id if sys_bio_model.biomodel_id else 'upload',
+            'tool_call_id': tool_call_id,
+            'data': df_param_scan.to_dict()
+        })
+    return list_dic_scanned_data
+def run_parameter_scan(model_object, arg_data, dic_species_data, duration, interval) -> dict:
+    """
+    Run parameter scan on the model.
+
+    Args:
+        model_object: The model object.
+        arg_data: The argument data.
+        dic_species_data: Dictionary of species data.
+        duration: Duration of the simulation.
+        interval: Interval between time points in the simulation.
+
+    Returns:
+        dict: Dictionary of parameter scan results. Each key is a species name
+        and each value is a DataFrame containing the results of the parameter scan.
+    """
+    # Extract all parameter names from the model and verify if the given parameter name is valid
+    df_all_parameters = basico.model_info.get_parameters(model=model_object.copasi_model)
+    all_parameters = df_all_parameters.index.tolist()
+    if arg_data.parameter_scan_data.parameter_name not in all_parameters:
+        logger.error(
+            "Invalid parameter name: %s", arg_data.parameter_scan_data.parameter_name)
+        raise ValueError(
+            f"Invalid parameter name: {arg_data.parameter_scan_data.parameter_name}")
+    # Extract all species name from the model and verify if the given species name is valid
+    df_all_species = basico.model_info.get_species(model=model_object.copasi_model)
+    all_species = df_all_species['display_name'].tolist()
+    # Dictionary to store the parameter scan results
+    dic_param_scan_results = {}
+    for species_name in arg_data.parameter_scan_data.species_names:
+        if species_name not in all_species:
+            logger.error("Invalid species name: %s", species_name)
+            raise ValueError(f"Invalid species name: {species_name}")
+        # Update the fixed model species and parameters
+        # These are the initial conditions of the model
+        # set by the user
+        model_object.update_parameters(dic_species_data)
+        # Initialize empty DataFrame to store results
+        # of the parameter scan
+        df_param_scan = pd.DataFrame()
+        for param_value in arg_data.parameter_scan_data.parameter_values:
+            # Update the parameter value in the model
+            model_object.update_parameters(
+                {arg_data.parameter_scan_data.parameter_name: param_value})
+            # Simulate the model
+            model_object.simulate(duration=duration, interval=interval)
+            # If the column name 'Time' is not present in the results DataFrame
+            if 'Time' not in df_param_scan.columns:
+                df_param_scan['Time'] = model_object.simulation_results['Time']
+            # Add the simulation results to the results DataFrame
+            col_name = f"{arg_data.parameter_scan_data.parameter_name}_{param_value}"
+            df_param_scan[col_name] = model_object.simulation_results[species_name]
+
+        logger.log(logging.INFO, "Parameter scan results with shape %s", df_param_scan.shape)
+        # Add the results of the parameter scan to the dictionary
+        dic_param_scan_results[species_name] = df_param_scan
+    # return df_param_scan
+    return dic_param_scan_results
+
+class ParameterScanInput(BaseModel):
+    """
+    Input schema for the ParameterScan tool.
+    """
+    sys_bio_model: ModelData = Field(description="model data",
+                                     default=None)
+    arg_data: ArgumentData = Field(description=
+                                   """time, species, and reocurring data
+                                   as well as the parameter scan name and
+                                   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.
+class ParameterScanTool(BaseTool):
+    """
+    Tool for parameter scan.
+    """
+    name: str = "parameter_scan"
+    description: str = """A tool to perform parameter scan
+        of a list of parameter values for a given species."""
+    args_schema: Type[BaseModel] = ParameterScanInput
+
+    def _run(self,
+        tool_call_id: Annotated[str, InjectedToolCallId],
+        state: Annotated[dict, InjectedState],
+        sys_bio_model: ModelData = None,
+        arg_data: ArgumentData = None
+    ) -> Command:
+        """
+        Run the tool.
+
+        Args:
+            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:
+            Command: The updated state of the tool.
+        """
+        logger.log(logging.INFO, "Calling parameter_scan 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
+        duration = 100.0
+        interval = 10
+        dic_species_data = {}
+        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 reocurring events (if any) to the model
+            if arg_data.reocurring_data is not None:
+                add_rec_events(model_object, arg_data.reocurring_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
+
+        # Run the parameter scan
+        dic_param_scan = run_parameter_scan(model_object,
+                                           arg_data,
+                                           dic_species_data,
+                                           duration,
+                                           interval)
+
+        logger.log(logging.INFO, "Parameter scan results ready")
+        # Prepare the list dictionary of scanned data
+        list_dic_scanned_data = make_list_dic_scanned_data(dic_param_scan,
+                                                           arg_data,
+                                                           sys_bio_model,
+                                                           tool_call_id)
+        # 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],
+            "dic_scanned_data": list_dic_scanned_data,
+            }.items():
+            if value:
+                dic_updated_state_for_model[key] = value
+        # Return the updated state
+        return Command(
+                update=dic_updated_state_for_model|{
+                # update the message history
+                "messages": [
+                    ToolMessage(
+                        content=f"Parameter scan results of {arg_data.scan_name}",
+                        tool_call_id=tool_call_id
+                        )
+                    ],
+                }
+            )

aiagents4pharma/talk2biomodels/tools/simulate_model.py

@@ -138,7 +138,7 @@ class SimulateModelTool(BaseTool):
         # of the BasicoModel class
         duration = 100.0
         interval = 10
-        dic_species_data = None
+        dic_species_data = {}
         if arg_data:
             # Prepare the dictionary of species data
             if arg_data.species_data is not None:
@@ -151,22 +151,21 @@ class SimulateModelTool(BaseTool):
             if arg_data.time_data is not None:
                 duration = arg_data.time_data.duration
                 interval = arg_data.time_data.interval
-
+        # Update the model parameters
+        model_object.update_parameters(dic_species_data)
+        logger.log(logging.INFO,
+                   "Following species/parameters updated in the model %s",
+                   dic_species_data)
         # Simulate the model
-        df = model_object.simulate(
-            parameters=dic_species_data,
-            duration=duration,
-            interval=interval
-            )
-
+        df = model_object.simulate(duration=duration, interval=interval)
+        logger.log(logging.INFO, "Simulation results ready with shape %s", df.shape)
         dic_simulated_data = {
             'name': arg_data.simulation_name,
             'source': sys_bio_model.biomodel_id if sys_bio_model.biomodel_id else 'upload',
             'tool_call_id': tool_call_id,
             'data': df.to_dict()
         }
-
-        # Prepare the dictionary of updated state for the model
+        # Prepare the dictionary of updated state
         dic_updated_state_for_model = {}
         for key, value in {
             "model_id": [sys_bio_model.biomodel_id],
@@ -175,7 +174,6 @@ class SimulateModelTool(BaseTool):
             }.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|{

aiagents4pharma/talk2knowledgegraphs/__init__.py

@@ -1,4 +1,5 @@
 '''
-This file is used to import the datasets, utils, and tools.
+This file is used to import the datasets and utils.
 '''
 from . import datasets
+from . import utils

aiagents4pharma/talk2knowledgegraphs/tests/test_utils_enrichments_enrichments.py

@@ -0,0 +1,39 @@
+"""
+Test cases for utils/enrichments/enrichments.py
+"""
+
+from ..utils.enrichments.enrichments import Enrichments
+
+class TestEnrichments(Enrichments):
+    """Test implementation of the Enrichments interface for testing purposes."""
+
+    def enrich_documents(self, texts: list[str]) -> list[list[float]]:
+        return [
+            f"Additional text description of {text} as the input." for text in texts
+        ]
+
+    def enrich_documents_with_rag(self, texts, docs):
+        # Currently we don't have a RAG model to test this method.
+        # Thus, we will just call the enrich_documents method instead.
+        return self.enrich_documents(texts)
+
+def test_enrich_documents():
+    """Test enriching documents using the Enrichments interface."""
+    enrichments = TestEnrichments()
+    texts = ["text1", "text2"]
+    result = enrichments.enrich_documents(texts)
+    assert result == [
+        "Additional text description of text1 as the input.",
+        "Additional text description of text2 as the input.",
+    ]
+
+def test_enrich_documents_with_rag():
+    """Test enriching documents with RAG using the Enrichments interface."""
+    enrichments = TestEnrichments()
+    texts = ["text1", "text2"]
+    docs = ["doc1", "doc2"]
+    result = enrichments.enrich_documents_with_rag(texts, docs)
+    assert result == [
+        "Additional text description of text1 as the input.",
+        "Additional text description of text2 as the input.",
+    ]

aiagents4pharma/talk2knowledgegraphs/tests/test_utils_enrichments_ollama.py

@@ -0,0 +1,117 @@
+"""
+Test cases for utils/enrichments/ollama.py
+"""
+
+import pytest
+import ollama
+from ..utils.enrichments.ollama import EnrichmentWithOllama
+
+@pytest.fixture(name="ollama_config")
+def fixture_ollama_config():
+    """Return a dictionary with Ollama configuration."""
+    return {
+        "model_name": "smollm2:360m",
+        "prompt_enrichment": """
+            Given the input as a list of strings, please return the list of addditional information of
+            each input terms using your prior knowledge.
+
+            Example:
+            Input: ['acetaminophen', 'aspirin']
+            Ouput: ['acetaminophen is a medication used to treat pain and fever', 
+            'aspirin is a medication used to treat pain, fever, and inflammation']
+            
+            Do not include any pretext as the output, only the list of strings enriched.
+
+            Input: {input}
+        """,
+        "temperature": 0.0,
+        "streaming": False,
+    }
+
+def test_no_model_ollama(ollama_config):
+    """Test the case when the Ollama model is not available."""
+    cfg = ollama_config
+    cfg_model = "smollm2:135m" # Choose a small model
+
+    # Delete the Ollama model
+    try:
+        ollama.delete(cfg_model)
+    except ollama.ResponseError:
+        pass
+
+    # Check if the model is available
+    with pytest.raises(
+        ValueError, match=f"Error: Pulled {cfg_model} model and restarted Ollama server."
+    ):
+        EnrichmentWithOllama(
+            model_name=cfg_model,
+            prompt_enrichment=cfg["prompt_enrichment"],
+            temperature=cfg["temperature"],
+            streaming=cfg["streaming"],
+        )
+    ollama.delete(cfg_model)
+
+def test_enrich_nodes_ollama(ollama_config):
+    """Test the Ollama textual enrichment class for node enrichment."""
+    # Prepare enrichment model
+    cfg = ollama_config
+    enr_model = EnrichmentWithOllama(
+        model_name=cfg["model_name"],
+        prompt_enrichment=cfg["prompt_enrichment"],
+        temperature=cfg["temperature"],
+        streaming=cfg["streaming"],
+    )
+
+    # Perform enrichment for nodes
+    nodes = ["Adalimumab", "Infliximab"]
+    enriched_nodes = enr_model.enrich_documents(nodes)
+    # Check the enriched nodes
+    assert len(enriched_nodes) == 2
+    assert all(
+        enriched_nodes[i] != nodes[i] for i in range(len(nodes))
+    )
+
+
+def test_enrich_relations_ollama(ollama_config):
+    """Test the Ollama textual enrichment class for relation enrichment."""
+    # Prepare enrichment model
+    cfg = ollama_config
+    enr_model = EnrichmentWithOllama(
+        model_name=cfg["model_name"],
+        prompt_enrichment=cfg["prompt_enrichment"],
+        temperature=cfg["temperature"],
+        streaming=cfg["streaming"],
+    )
+    # Perform enrichment for relations
+    relations = [
+        "IL23R-gene causation disease-inflammatory bowel diseases",
+        "NOD2-gene causation disease-inflammatory bowel diseases",
+    ]
+    enriched_relations = enr_model.enrich_documents(relations)
+    # Check the enriched relations
+    assert len(enriched_relations) == 2
+    assert all(
+        enriched_relations[i] != relations[i]
+        for i in range(len(relations))
+    )
+
+
+def test_enrich_ollama_rag(ollama_config):
+    """Test the Ollama textual enrichment class for enrichment with RAG (not implemented)."""
+    # Prepare enrichment model
+    cfg = ollama_config
+    enr_model = EnrichmentWithOllama(
+        model_name=cfg["model_name"],
+        prompt_enrichment=cfg["prompt_enrichment"],
+        temperature=cfg["temperature"],
+        streaming=cfg["streaming"],
+    )
+    # Perform enrichment for nodes
+    nodes = ["Adalimumab", "Infliximab"]
+    docs = [r"\path\to\doc1", r"\path\to\doc2"]
+    enriched_nodes = enr_model.enrich_documents_with_rag(nodes, docs)
+    # Check the enriched nodes
+    assert len(enriched_nodes) == 2
+    assert all(
+        enriched_nodes[i] != nodes[i] for i in range(len(nodes))
+    )

aiagents4pharma/talk2knowledgegraphs/utils/__init__.py

@@ -0,0 +1,5 @@
+'''
+This file is used to import utlities.
+'''
+from . import enrichments
+from . import embeddings

aiagents4pharma/talk2knowledgegraphs/utils/enrichments/__init__.py

@@ -0,0 +1,5 @@
+"""
+This package contains modules to use the enrichment model
+"""
+from . import enrichments
+from . import ollama

aiagents4pharma/talk2knowledgegraphs/utils/enrichments/enrichments.py

@@ -0,0 +1,36 @@
+"""
+Enrichments interface
+"""
+
+from abc import ABC, abstractmethod
+
+class Enrichments(ABC):
+    """Interface for enrichment models.
+
+    This is an interface meant for implementing text enrichment models.
+
+    Enrichment models are used to enrich node or relation features in a given knowledge graph.
+    """
+
+    @abstractmethod
+    def enrich_documents(self, texts: list[str]) -> list[list[str]]:
+        """Enrich documents.
+
+        Args:
+            texts: List of documents to enrich.
+
+        Returns:
+            List of enriched documents.
+        """
+
+    @abstractmethod
+    def enrich_documents_with_rag(self, texts: list[str], docs: list[str]) -> list[str]:
+        """Enrich documents with RAG.
+
+        Args:
+            texts: List of documents to enrich.
+            docs: List of reference documents to enrich the input texts.
+
+        Returns:
+            List of enriched documents with RAG.
+        """

aiagents4pharma/talk2knowledgegraphs/utils/enrichments/ollama.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+
+"""
+Enrichment class using Ollama model based on LangChain Enrichment class.
+"""
+
+import time
+from typing import List
+import subprocess
+import ast
+import ollama
+from langchain_ollama import ChatOllama
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from .enrichments import Enrichments
+
+class EnrichmentWithOllama(Enrichments):
+    """
+    Enrichment class using Ollama model based on the Enrichment abstract class.
+    """
+    def __init__(
+        self,
+        model_name: str,
+        prompt_enrichment: str,
+        temperature: float,
+        streaming: bool,
+    ):
+        """
+        Initialize the EnrichmentWithOllama class.
+
+        Args:
+            model_name: The name of the Ollama model to be used.
+            prompt_enrichment: The prompt enrichment template.
+            temperature: The temperature for the Ollama model.
+            streaming: The streaming flag for the Ollama model.
+        """
+        # Setup the Ollama server
+        self.__setup(model_name)
+
+        # Set parameters
+        self.model_name = model_name
+        self.prompt_enrichment = prompt_enrichment
+        self.temperature = temperature
+        self.streaming = streaming
+
+        # Prepare prompt template
+        self.prompt_template = ChatPromptTemplate.from_messages(
+            [
+                ("system", self.prompt_enrichment),
+                ("human", "{input}"),
+            ]
+        )
+
+        # Prepare model
+        self.model = ChatOllama(
+            model=self.model_name,
+            temperature=self.temperature,
+            streaming=self.streaming,
+        )
+
+    def __setup(self, model_name: str) -> None:
+        """
+        Check if the Ollama model is available and run the Ollama server if needed.
+
+        Args:
+            model_name: The name of the Ollama model to be used.
+        """
+        try:
+            models_list = ollama.list()["models"]
+            if model_name not in [m['model'].replace(":latest", "") for m in models_list]:
+                ollama.pull(model_name)
+                time.sleep(30)
+                raise ValueError(f"Pulled {model_name} model")
+        except Exception as e:
+            with subprocess.Popen(
+                "ollama serve", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+            ):
+                time.sleep(10)
+            raise ValueError(f"Error: {e} and restarted Ollama server.") from e
+
+    def enrich_documents(self, texts: List[str]) -> List[str]:
+        """
+        Enrich a list of input texts with additional textual features using OLLAMA model.
+        Important: Make sure the input is a list of texts based on the defined prompt template
+        with 'input' as the variable name.
+
+        Args:
+            texts: The list of texts to be enriched.
+
+        Returns:
+            The list of enriched texts.
+        """
+
+        # Perform enrichment
+        chain = self.prompt_template | self.model | StrOutputParser()
+
+        # Generate the enriched node
+        # Important: Make sure the input is a list of texts based on the defined prompt template
+        # with 'input' as the variable name
+        enriched_texts = chain.invoke({"input": "[" + ", ".join(texts) + "]"})
+
+        # Convert the enriched nodes to a list of dictionary
+        enriched_texts = ast.literal_eval(enriched_texts.replace("```", ""))
+
+        # Final check for the enriched texts
+        assert len(enriched_texts) == len(texts)
+
+        return enriched_texts
+
+    def enrich_documents_with_rag(self, texts, docs):
+        """
+        Enrich a list of input texts with additional textual features using OLLAMA model with RAG.
+        As of now, we don't have a RAG model to test this method yet.
+        Thus, we will just call the enrich_documents method instead.
+
+        Args:
+            texts: The list of texts to be enriched.
+            docs: The list of reference documents to enrich the input texts.
+        
+        Returns:
+            The list of enriched texts
+        """
+        return self.enrich_documents(texts)

{aiagents4pharma-1.10.0.dist-info → aiagents4pharma-1.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: aiagents4pharma
-Version: 1.10.0
+Version: 1.12.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
@@ -20,9 +20,11 @@ Requires-Dist: langchain-community==0.3.5
 Requires-Dist: langchain-core==0.3.31
 Requires-Dist: langchain-experimental==0.3.3
 Requires-Dist: langchain-openai==0.2.5
+Requires-Dist: langchain_ollama==0.2.2
 Requires-Dist: langgraph==0.2.66
 Requires-Dist: matplotlib==3.9.2
 Requires-Dist: openai==1.59.4
+Requires-Dist: ollama==0.4.6
 Requires-Dist: pandas==2.2.3
 Requires-Dist: plotly==5.24.1
 Requires-Dist: pydantic==2.9.2
@@ -74,6 +76,7 @@ Our toolkit currently consists of three intelligent agents, each designed to sim
 - Forward simulation of both internal and open-source models (BioModels).
 - Adjust parameters within the model to simulate different conditions.
 - Query simulation results.
+- Extract model information such as species, parameters, units and description.
 
 ### 2. Talk2Cells _(Work in Progress)_
 
@@ -87,11 +90,7 @@ Our toolkit currently consists of three intelligent agents, each designed to sim
 
 ## Getting Started
 
-### Prerequisites
-
-- **Python 3.10+**
-- **Git**
-- Required libraries specified in `requirements.txt`
+![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FVirtualPatientEngine%2FAIAgents4Pharma%2Frefs%2Fheads%2Fmain%2Fpyproject.toml)
 
 ### Installation
 

{aiagents4pharma-1.10.0.dist-info → aiagents4pharma-1.12.0.dist-info}/RECORD

@@ -7,23 +7,24 @@ aiagents4pharma/configs/talk2biomodels/agents/t2b_agent/__init__.py,sha256=-fAOR
 aiagents4pharma/configs/talk2biomodels/agents/t2b_agent/default.yaml,sha256=yD7qZCneaM-JE5PdZjDmDoTRUdsFrzeCKZsBx1b-f20,293
 aiagents4pharma/talk2biomodels/__init__.py,sha256=qUw3qXrENqSCLIKSLy_qtNPwPDTb1wdZ8fZispcHb3g,141
 aiagents4pharma/talk2biomodels/agents/__init__.py,sha256=sn5-fREjMdEvb-OUan3iOqrgYGjplNx3J8hYOaW0Po8,128
-aiagents4pharma/talk2biomodels/agents/t2b_agent.py,sha256=nVWxHR-QMZDqDwxvDga_CvLo7LHP5cWCDl6lXCMcRO0,3264
+aiagents4pharma/talk2biomodels/agents/t2b_agent.py,sha256=6Im4YFcdykN7wpEM8y9qi_x4lTg02WJpb0SEWh8TPLo,3188
 aiagents4pharma/talk2biomodels/models/__init__.py,sha256=5fTHHm3PVloYPNKXbgNlcPgv3-u28ZquxGydFYDfhJA,122
-aiagents4pharma/talk2biomodels/models/basico_model.py,sha256=js7ORLwbJPaIsko5oRToMMCh4l8LsN292OIvFzTfvRg,4946
-aiagents4pharma/talk2biomodels/models/sys_bio_model.py,sha256=ylpPba2SA8kl68q3k1kJbiUdRYplPHykyslTQLDZ19I,1995
+aiagents4pharma/talk2biomodels/models/basico_model.py,sha256=PH25FTOuUjsmw_UUxoRb-4kptOYpicEn4GqS0phS3nk,4807
+aiagents4pharma/talk2biomodels/models/sys_bio_model.py,sha256=JeoiGQAvQABHnG0wKR2XBmmxqQdtgO6kxaLDUTUmr1s,2001
 aiagents4pharma/talk2biomodels/states/__init__.py,sha256=YLg1-N0D9qyRRLRqwqfLCLAqZYDtMVZTfI8Y0b_4tbA,139
-aiagents4pharma/talk2biomodels/states/state_talk2biomodels.py,sha256=iob7q5Kpy6aWDLCiFsp4NNVYYXNdDU3vU50PmxyvBsU,792
+aiagents4pharma/talk2biomodels/states/state_talk2biomodels.py,sha256=Dlsnh9dW1mCXTBXmlDAlOox7f4azFbLBG_2k3YPielM,824
 aiagents4pharma/talk2biomodels/tests/__init__.py,sha256=Jbw5tJxSrjGoaK5IX3pJWDCNzhrVQ10lkYq2oQ_KQD8,45
-aiagents4pharma/talk2biomodels/tests/test_basico_model.py,sha256=uqhbojcA4RRTDRUAF9B9DzKCo3OOIOWMDK8IViG0gsM,2038
-aiagents4pharma/talk2biomodels/tests/test_langgraph.py,sha256=GyqsUpcWgjuRb15DpGvLg-FZ8g3_cf0TwVcaCPp_vO0,9456
-aiagents4pharma/talk2biomodels/tests/test_sys_bio_model.py,sha256=nA6bRT16627mw8qzrv7cHM9AByHb9F0kxAuwOpE-avA,1961
-aiagents4pharma/talk2biomodels/tools/__init__.py,sha256=8hAT6z1OO8N9HRylh6fwoqyjYlGdpkngkElBNqH40Zo,237
+aiagents4pharma/talk2biomodels/tests/test_basico_model.py,sha256=y82fpTJMPHwtXxlle1cGQ_2Bewwpxi0aJSVrVAYLhN0,2060
+aiagents4pharma/talk2biomodels/tests/test_langgraph.py,sha256=_71UZS1zucn6Nus4oCH7tINQVRvJEFnL0UIZ6-sUd3I,11967
+aiagents4pharma/talk2biomodels/tests/test_sys_bio_model.py,sha256=HSmBBViMi0jYf4gWX21IbppAfDzG0nr_S3KtKS9fZVQ,2165
+aiagents4pharma/talk2biomodels/tools/__init__.py,sha256=SMTMlGHxTuJI7gjwGaTMv0XmilJ73-r5dp568hD3Fw0,266
 aiagents4pharma/talk2biomodels/tools/ask_question.py,sha256=uxCQ4ON8--D0ACPvT14t6x_aqm9LP6woBA4GM7bPXc4,3061
 aiagents4pharma/talk2biomodels/tools/custom_plotter.py,sha256=HWwKTX3o4dk0GcRVTO2hPrFSu98mtJ4TKC_hbHXOe1c,4018
-aiagents4pharma/talk2biomodels/tools/get_modelinfo.py,sha256=68KmeEpgvgaDQM9airOWVy4fGT33rG10RlXhps5W6C0,5279
+aiagents4pharma/talk2biomodels/tools/get_modelinfo.py,sha256=qA-4FOI-O728Nmn7s8JJ8HKwxvA9MZbst7NkPKTAMV4,5391
 aiagents4pharma/talk2biomodels/tools/load_biomodel.py,sha256=pyVzLQoMnuJYEwsjeOlqcUrbU1F1Z-pNlgkhFaoKpy0,689
+aiagents4pharma/talk2biomodels/tools/parameter_scan.py,sha256=aIyL_m46s3Q74ieJOZjZBM34VCjBKSMpEtckhdZofbE,12139
 aiagents4pharma/talk2biomodels/tools/search_models.py,sha256=Iq2ddofOOfZYtAurCISq3bAq5rbwB3l_rL1lgEFyFCI,2653
-aiagents4pharma/talk2biomodels/tools/simulate_model.py,sha256=1HVoI5SkktvpOmTnAG8hxrhpoxpg_he-bb5ZJ_UllI4,6833
+aiagents4pharma/talk2biomodels/tools/simulate_model.py,sha256=sWmFVnVvJbdXXTqn_7gQl5UW0tv4FyU5yLXWLweLs_M,7059
 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
@@ -50,7 +51,7 @@ aiagents4pharma/talk2competitors/tools/s2/display_results.py,sha256=B8JJGohi1Eyx
 aiagents4pharma/talk2competitors/tools/s2/multi_paper_rec.py,sha256=FYLt47DAk6WOKfEk1Gj9zVvJGNyxA283PCp8IKW9U5M,4262
 aiagents4pharma/talk2competitors/tools/s2/search.py,sha256=pppjrQv5-8ep4fnqgTSBNgnbSnQsVIcNrRrH0p2TP1o,4025
 aiagents4pharma/talk2competitors/tools/s2/single_paper_rec.py,sha256=dAfUQxI7T5eu0eDxK8VAl7-JH0Wnw24CVkOQqwj-hXc,4810
-aiagents4pharma/talk2knowledgegraphs/__init__.py,sha256=SW7Ys2A4eXyFtizNPdSw91SHOPVUBGBsrCQ7TqwSUL0,91
+aiagents4pharma/talk2knowledgegraphs/__init__.py,sha256=4smVQoSMM6rflVnNkABqlDAAlSn4bYsq7rMVWjRGvis,103
 aiagents4pharma/talk2knowledgegraphs/datasets/__init__.py,sha256=L3gPuHskSegmtXskVrLIYr7FXe_ibKgJ2GGr1_Wok6k,173
 aiagents4pharma/talk2knowledgegraphs/datasets/biobridge_primekg.py,sha256=QlzDXmXREoa9MA6-GwzqRjdzndQeGBAF11Td6NFk_9Y,23426
 aiagents4pharma/talk2knowledgegraphs/datasets/dataset.py,sha256=-LaPLse8BkALqwFetNK7wch2dt9Dz6QKGKZKBKM6bIk,409
@@ -64,14 +65,19 @@ aiagents4pharma/talk2knowledgegraphs/tests/test_datasets_starkqa_primekg.py,sha2
 aiagents4pharma/talk2knowledgegraphs/tests/test_utils_embeddings_embeddings.py,sha256=uYFoE_6zeU10_1mLLAHUr5c4S2XZMSc0Q_860o-KWEw,1517
 aiagents4pharma/talk2knowledgegraphs/tests/test_utils_embeddings_huggingface.py,sha256=EINWyXg_3AMHF3WzFLhIUiFDuaEhTVHBvVAJr8VtMDg,1624
 aiagents4pharma/talk2knowledgegraphs/tests/test_utils_embeddings_sentencetransformer.py,sha256=Qxo6WeIDRy8aLh1tNKw0kSlzmUj3MtTak63oW2YwB24,1327
-aiagents4pharma/talk2knowledgegraphs/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiagents4pharma/talk2knowledgegraphs/tests/test_utils_enrichments_enrichments.py,sha256=N6HRr4lWHXY7bTHe2uXJe4D_EG9WqZPibZne6qLl9_k,1447
+aiagents4pharma/talk2knowledgegraphs/tests/test_utils_enrichments_ollama.py,sha256=kMuB_vci6hKr2qJgXBmcje7yxeJ2nY2ImXw-NSJpts0,3912
+aiagents4pharma/talk2knowledgegraphs/utils/__init__.py,sha256=X8kSpmDTMkeE0fA5D0CWMsQ52YKoM5rRSXrjnali3IM,97
 aiagents4pharma/talk2knowledgegraphs/utils/kg_utils.py,sha256=6vQnPkeOWae_8jePjhma3sJuMTngy0I0tqzdFt6OqKg,2507
 aiagents4pharma/talk2knowledgegraphs/utils/embeddings/__init__.py,sha256=xRb0x7SoAb0nSVZYgjrqxWvENOMDuqIdL43NMjoOaCs,153
 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.10.0.dist-info/LICENSE,sha256=IcIbyB1Hyk5ZDah03VNQvJkbNk2hkBCDqQ8qtnCvB4Q,1077
-aiagents4pharma-1.10.0.dist-info/METADATA,sha256=a5XUji4VHk7HcE5GC7txe7v2sNUbgH4ijSHpxoNh74E,8340
-aiagents4pharma-1.10.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-aiagents4pharma-1.10.0.dist-info/top_level.txt,sha256=-AH8rMmrSnJtq7HaAObS78UU-cTCwvX660dSxeM7a0A,16
-aiagents4pharma-1.10.0.dist-info/RECORD,,
+aiagents4pharma/talk2knowledgegraphs/utils/enrichments/__init__.py,sha256=tW426knki2DBIHcWyF_K04iMMdbpIn_e_TpPmTgz2dI,113
+aiagents4pharma/talk2knowledgegraphs/utils/enrichments/enrichments.py,sha256=Bx8x6zzk5614ApWB90N_iv4_Y_Uq0-KwUeBwYSdQMU4,924
+aiagents4pharma/talk2knowledgegraphs/utils/enrichments/ollama.py,sha256=8eoxR-VHo0G7ReQIwje7xEhE-SJlHdef7_wJRpnvFIc,4116
+aiagents4pharma-1.12.0.dist-info/LICENSE,sha256=IcIbyB1Hyk5ZDah03VNQvJkbNk2hkBCDqQ8qtnCvB4Q,1077
+aiagents4pharma-1.12.0.dist-info/METADATA,sha256=Okx1RPc3qMmJ2a7ca2YvSFr7-gxqAR51LVLkOTh5O2k,8609
+aiagents4pharma-1.12.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+aiagents4pharma-1.12.0.dist-info/top_level.txt,sha256=-AH8rMmrSnJtq7HaAObS78UU-cTCwvX660dSxeM7a0A,16
+aiagents4pharma-1.12.0.dist-info/RECORD,,