update from 10/06/2025

app.py

@@ -63,34 +63,39 @@ def select_best_model(
 
 # Definition of the tools for the MCP server 
 # Function to return a fasta file
-def create_fasta_file(sequence: str, name: Optional[str] = None, seq_name: Optional[str] = None) -> str:
+def create_fasta_file(file_content: str, name: Optional[str] = None, seq_name: Optional[str] = None) -> str:
     """Create a FASTA file from a protein sequence string with a unique name.
     
     Args:
-        sequence (str): The protein sequence string with optional line breaks
-        name (str, optional): Name to use for the FASATA file. If not provided, a unique ID will be generated
-        seq_name (str, optional): The name/identifier for the sequence. Defaults to "PROTEIN"
+        file_content (str): The content of the FASTA file required with optional line breaks
+        name (str, optional): FASTA file name ending with .fasta ideally. If not provided, a unique ID will be generated
+        seq_name (str, optional): The name/identifier for the sequence. Defaults to "protein"
         
     
     Returns:
         str: Name of the created FASTA file
     """
+    # If the file_content is empty, raise an error
+    if not file_content.strip():
+        print("Fasta file content cannot be empty so the example fasta file will be used")
+        file_content = ">protein|name=example-protein\nAGSHSMRYFSTSVSRPGRGEPRFIAVGYVDDTQFVRFD"
+    
     # Remove any trailing/leading whitespace but preserve line breaks
-    lines = sequence.strip().split('\n')
+    lines = file_content.strip().split('\n')
     
     # Check if the first line is a FASTA header
     if not lines[0].startswith('>'):
         # If no header provided, add one
         if seq_name is None:
-            seq_name = "PROTEIN"
-        sequence = f">{seq_name}\n{sequence}"
+            seq_name = "protein"
+        file_content = f">{seq_name}\n{file_content}"
     
     # Create FASTA content (preserving line breaks)
-    fasta_content = sequence
+    fasta_content = file_content
     
     # Generate a unique file name
     unique_id = hashlib.sha256(uuid4().bytes).hexdigest()[:8]
-    file_name = f"chai1_{name if name else unique_id}_input.fasta"
+    file_name = f"{name if name else unique_id}"
     file_path = here / "inputs/fasta" / file_name
     
     # Write the FASTA file
@@ -113,7 +118,7 @@ def create_json_config(
         num_trunk_recycles (int): Number of trunk recycles from slider
         seed (int): Random seed from slider
         options (list): List of selected options from checkbox group
-        name (str, optional): Name to use for the config file. If not provided, a unique ID will be generated
+        name (str, optional): JSON config file name ending with .json ideally. If not provided, a unique ID will be generated
     
     Returns:
         str: Name of the created JSON file
@@ -132,7 +137,7 @@ def create_json_config(
     }
     
     # Generate file name based on provided name or unique ID
-    file_name = f"chai1_{name if name else hashlib.sha256(uuid4().bytes).hexdigest()[:8]}_config.json"
+    file_name = f"{name if name else hashlib.sha256(uuid4().bytes).hexdigest()[:8]}"
     file_path = here / "inputs/config" / file_name
     
     # Write the JSON file 
@@ -142,43 +147,43 @@ def create_json_config(
 
 # Function to compute Chai1 inference
 def compute_Chai1(
-    fasta_file: Optional[str] = "",
-    inference_config_file: Optional[str] = "",
+    fasta_file_name: Optional[str] = "",
+    inference_config_file_name: Optional[str] = "",
 ):
     """Compute a Chai1 simulation.
 
     Args:
-        fasta_file (str, optional): FASTA file name containing the protein sequence.
+        fasta_file_name (str, optional): FASTA file name to use for the Chai1 simulation.
             If not provided, uses the default input file.
-        inference_config_file (str, optional): JSON configuration file name for inference.
+        inference_config_file_name (str, optional): JSON configuration file name for inference.
             If not provided, uses the default quick inference configuration.
 
     Returns:
-        str: Output PDB file name containing the predicted structure.
+        pd.DataFrame: DataFrame containing model scores and CIF file paths
     """
+    import pandas as pd
     with app.run():
-        
         force_redownload = False
         
         print("🧬 checking inference dependencies")
         download_inference_dependencies.remote(force=force_redownload)
 
-        # Define fasta file
-        if not fasta_file:
-            fasta_file = here / "inputs/fasta" / "chai1_default_input.fasta"   
-        print(f"🧬 running Chai inference on {fasta_file}")
-        fasta_file = here / "inputs/fasta" / fasta_file
-        print(fasta_file)
-        fasta_content = Path(fasta_file).read_text()
+        # Define fasta file
+        if not fasta_file_name:
+            fasta_file_name = here / "inputs/fasta" / "chai1_default_input.fasta"   
+        print(f"🧬 running Chai inference on {fasta_file_name}")
+        fasta_file_name = here / "inputs/fasta" / fasta_file_name
+        print(fasta_file_name)
+        fasta_content = Path(fasta_file_name).read_text()
 
         # Define inference config file
-        if not inference_config_file:
-            inference_config_file = here / "inputs/config" / "chai1_quick_inference.json"
-        inference_config_file = here / "inputs/config" / inference_config_file
-        print(f"🧬 loading Chai inference config from {inference_config_file}")
-        inference_config = json.loads(Path(inference_config_file).read_text())
+        if not inference_config_file_name:
+            inference_config_file_name = here / "inputs/config" / "chai1_quick_inference.json"
+        inference_config_file_name = here / "inputs/config" / inference_config_file_name
+        print(f"🧬 loading Chai inference config from {inference_config_file_name}")
+        inference_config = json.loads(Path(inference_config_file_name).read_text())
 
-        # Generate a unique run ID
+        # Generate a unique run ID
         run_id = hashlib.sha256(uuid4().bytes).hexdigest()[:8]  # short id
         print(f"🧬 running inference with {run_id=}")
 
@@ -189,24 +194,82 @@ def compute_Chai1(
         output_dir.mkdir(parents=True, exist_ok=True)
 
         print(f"🧬 saving results to disk locally in {output_dir}")
+        
+        # Create lists to store data for DataFrame
+        model_data = []
+        
         for ii, (scores, cif) in enumerate(results):
-            (Path(output_dir, "score") / f"{run_id}-scores.model_idx_{ii}.npz").write_bytes(scores)
-            (Path(output_dir, "molecules") / f"{run_id}-preds.model_idx_{ii}.cif").write_text(cif)
+            score_file = Path(output_dir, "score") / f"{run_id}-scores.model_idx_{ii}.npz"
+            cif_file = Path(output_dir, "molecules") / f"{run_id}-preds.model_idx_{ii}.cif"
+            
+            score_file.write_bytes(scores)
+            cif_file.write_text(cif)
+            
+            # Load score data
+            data = load(str(score_file))
+            
+            if not data["has_inter_chain_clashes"][0]:
+                model_data.append({
+                    "Model Index": ii,
+                    "Aggregate Score": float(data["aggregate_score"][0]),
+                    "PTM": float(data["ptm"][0]),
+                    "IPTM": float(data["iptm"][0]),
+                    "CIF File": str(cif_file).split("/")[-1],  # Get just the file name
+                })
         
-        best_model, max_aggregate_score = select_best_model(
-            run_id=run_id,
-            scores_to_print=["aggregate_score", "ptm", "iptm"],
-            number_of_scores=len(results),
-            results_dir=str(Path(output_dir, "score"))
-        )
-        # Take the last cif file and convert it to pdb
-        cif_name = str(Path(output_dir, "molecules"))+"/"+str(run_id)+"-preds.model_idx_"+str(best_model)+".cif"
-        pdb_name = cif_name.split('.cif')[0] + '.pdb'
-        st = gemmi.read_structure(cif_name)
-        st.write_minimal_pdb(pdb_name)
+        # Create DataFrame from collected data
+        results_df = pd.DataFrame(model_data).sort_values("Aggregate Score", ascending=False)
         
-        return pdb_name
+        return results_df
+
+
+# Function to plot the 3D protein structure
+def plot_protein(result_df) -> str:
+    """Plot the 3D structure of a protein using the DataFrame from compute_Chai1.
 
+    Args:
+        result_df (pd.DataFrame): DataFrame containing model information and scores
+
+    Returns:
+        str: Path to the generated PDB file of the best model.
+    """
+    if result_df.empty:
+        return ""  # Return empty string instead of None for type safety
+    
+    # Get the CIF file path of the model with highest aggregate score (already sorted)
+    best_cif = str(Path("results/molecules") / result_df.iloc[0]["CIF File"])
+    
+    # Generate PDB file name
+    pdb_file = best_cif.replace('.cif', '.pdb')
+    
+    # Convert CIF to PDB if it doesn't exist
+    if not Path(pdb_file).exists():
+        st = gemmi.read_structure(best_cif)
+        st.write_minimal_pdb(pdb_file)
+    
+    return pdb_file
+
+# Function to plot a CIF file
+def show_cif_file(cif_file):
+    """Plot a 3D structure from a CIF file with the Molecule3D library.
+
+    Args:
+        cif_file: A protein structure file in CIF format. This can be a file uploaded by the user.
+            If None, the function will return None.
+
+    Returns:
+        str or None: PDB file name if successful, None if no file was provided
+            or if conversion failed.
+    """
+    if not cif_file:
+        return None
+    
+    cif_path = Path(cif_file.name)
+    st = gemmi.read_structure(str(cif_path))
+    pdb_file = cif_path.with_suffix('.pdb')
+    st.write_minimal_pdb(str(pdb_file))  # Convert PosixPath to string
+    
+    return str(pdb_file)
 
 # Create the Gradio interface
 reps = [{"model": 0,"style": "cartoon","color": "hydrophobicity"}]
@@ -223,100 +286,16 @@ with gr.Blocks(theme=theme) as demo:
         
         gr.Image("images/logo1.png", show_label=False,width=400)
         
-        gr.Markdown(
-        """
-        
-        # Stakes 
-        
-        The industry is being deeply changed by the development of LLMs and the recent possibilities to provide them access to external tools. 
-        For years now companies are using simulation tools in order faster and reduce the development cost of a product. 
-        One of the challenge in the coming years will be to create agents that can setup, run and process simulations to faster the development of new products.
-        
-        # Objective 
-        
-        This project is a first step in this creating AI agents that perform simulations on existing softwares. 
-        1) Several domains are of major interest: 
-        - CFD (Computational Fluid Dynamics) simulations
-        - Biology simulations (Protein Folding, Molecular Dynamics, etc.)
-        - All applications that use neural networks
-        
-        --> This project is focused on the protein folding domain, but the same principles can be applied to other domains.
-        
-        2) Generally, industrial computations are performed on HPC clusters, which have access to large ressources. 
-        
-        --> The simulation need to run on a separate server
-        
-        3) The LLM needs to be able to access the simulation results in order to provide a complete answer to the user.
-        
-        --> The simulation results need to be accessible by the LLM
-        
-        ## Modal
-        
-        Modal (https://modal.com/) is a serverless platform that provides a simple way to run any application with the latest CPU and GPU hardware.
-    
-        ## Chai-1 Model
-        
-        Chai-1 (https://www.chaidiscovery.com/blog/introducing-chai-1) is a multi-modal foundation model for molecular structure prediction that performs at the state-of-the-art across a variety of benchmarks. 
-        Chai-1 enables unified prediction of proteins, small molecules, DNA, RNA, glycosylations, and more.
-        Chai-1 use on Modal server is an example on how to run folding simulations. 
-        Thus, it is a good choice to start with. 
-        
-        # Instructions
-        1. Upload a Fasta sequence file containing the molecule sequence.
-        2. Click the "Run" button to start the simulation.
-        3. The output will be a 3D visualization of the molecule.
-        
-        ## Simulation parameters choice       
-        If no config or fasta files are created, default values are chosen:
-        - chai1_default_input.fasta
-        - chai1_quick_inference.json
-        
-        The files content is diplayed at the bottom of the page.
-        The default json configuration makes the computation fast (about 2min) but results can be disappointing. 
-        Please use chai1_default_inference.json to have a wonderful protein 😃.
-        
-        - chai1_default_input.fasta
-        ```
-        >protein|name=example-of-long-protein
-        AGSHSMRYFSTSVSRPGRGEPRFIAVGYVDDTQFVRFDSDAASPRGEPRAPWVEQEGPEYWDRETQKYKRQAQTDRVSLRNLRGYYNQSEAGSHTLQWMFGCDLGPDGRLLRGYDQSAYDGKDYIALNEDLRSWTAADTAAQITQRKWEAAREAEQRRAYLEGTCVEWLRRYLENGKETLQRAEHPKTHVTHHPVSDHEATLRCWALGFYPAEITLTWQWDGEDQTQDTELVETRPAGDGTFQKWAAVVVPSGEEQRYTCHVQHEGLPEPLTLRWEP
-        >protein|name=example-of-short-protein
-        AIQRTPKIQVYSRHPAENGKSNFLNCYVSGFHPSDIEVDLLKNGERIEKVEHSDLSFSKDWSFYLLYYTEFTPTEKDEYACRVNHVTLSQPKIVKWDRDM
-        >protein|name=example-peptide
-        GAAL
-        >ligand|name=example-ligand-as-smiles
-        CCCCCCCCCCCCCC(=O)O
-        ```
-        - chai1_quick_inference.json
-        ```json
-        {
-            "num_trunk_recycles": 1,
-            "num_diffn_timesteps": 10,
-            "seed": 42,
-            "use_esm_embeddings": true
-            "use_msa_server": false
-        }
-        ```
-        
-        # Work performed
-        This interface allows you to run Chai1 simulations on a given Fasta sequence file.
-        The Chai1 model is designed to predict the 3D structure of proteins based on their amino acid sequences.
-        You can input a Fasta file containing the sequence of the molecule you want to simulate, and the output will be a 3D representation of the molecule based on the Chai1 model.
-
-        You can input a Fasta file containing the sequence of the molecule you want to simulate.
-        The output will be a 3D representation of the molecule based on the Chai1 model.
-        
-        # Disclaimer
-        This interface is for educational and research purposes only. The results may vary based on the input sequence and the Chai1 model's capabilities.
-        # Contact
-        For any issues or questions, please contact the developer or refer to the documentation.   
-        """) 
+        with open("introduction_page.md", "r") as f:
+            intro_md = f.read()
+        gr.Markdown(intro_md)
     
     
     with gr.Tab("Configuration 📦"):
         
         gr.Markdown(
         """        
-        ## Fasta file and configuration generator
+        ## Fasta file and configuration generator (optional)
         """)
         
         with gr.Row():
@@ -324,15 +303,15 @@ with gr.Blocks(theme=theme) as demo:
                 slider_nb = gr.Slider(1, 500, value=300, label="Number of diffusion time steps", info="Choose the number of diffusion time steps for the simulation", step=1, interactive=True, elem_id="num_iterations")
                 slider_trunk = gr.Slider(1, 5, value=3, label="Number of trunk recycles", info="Choose the number of iterations for the simulation", step=1, interactive=True, elem_id="trunk_number")
                 slider_seed = gr.Slider(1, 100, value=42, label="Seed", info="Choose the seed", step=1, interactive=True, elem_id="seed")
-                check_options = gr.CheckboxGroup(["ESM_embeddings", "MSA_server"], value=["ESM_embeddings",], label="Additionnal options", info="Options to use ESM embeddings and MSA server", elem_id="options")
-                config_name = gr.Textbox(placeholder="Enter a name for the config (optional)", label="Configuration file name")
+                check_options = gr.CheckboxGroup(["ESM_embeddings", "MSA_server"], value=["ESM_embeddings",], label="Additional options", info="Options to use ESM embeddings and MSA server", elem_id="options")
+                config_name = gr.Textbox(placeholder="Enter a name for the json file (optional)", label="JSON file name")
                 button_json = gr.Button("Create Config file")
                 button_json.click(fn=create_json_config, inputs=[slider_nb, slider_trunk, slider_seed, check_options, config_name], outputs=[])
         
                 
             with gr.Column(scale=1):   
                 fasta_input = gr.Textbox(placeholder="Fasta format sequences", label="Fasta content", lines=10)
-                fasta_name = gr.Textbox(placeholder="Enter a name for the fasta file (optional)", label="Fasta file name")
+                fasta_name = gr.Textbox(placeholder="Enter the name of the fasta file name (optional)", label="Fasta file name")
                 fasta_button = gr.Button("Create Fasta file")
                 fasta_button.click(fn=create_fasta_file, inputs=[fasta_input, fasta_name], outputs=[])
                         
@@ -352,29 +331,52 @@ with gr.Blocks(theme=theme) as demo:
                 inp1 = gr.FileExplorer(root_dir=here / "inputs/fasta", 
                                 value="chai1_default_input.fasta",
                                 label="Input Fasta file", 
-                                file_count='single',
-                                glob="*.fasta")     
+                                file_count='single')     
                 
             with gr.Column(scale=1):
                 inp2 = gr.FileExplorer(root_dir=here / "inputs/config", 
                                 value="chai1_quick_inference.json",
                                 label="Configuration file", 
-                                file_count='single',
-                                glob="*.json")    
+                                file_count='single')    
         btn_refresh = gr.Button("Refresh available files")
         
         # Only workaround I found to update the file explorer
         def update_file_explorer():
+            """Don't need to be used by LLMs, but useful for the interface to update the file explorer"""
             return gr.FileExplorer(root_dir=here), gr.FileExplorer(root_dir=here)
         def update_file_explorer_2():
+            """Don't need to be used by LLMs, but useful for the interface to update the file explorer"""
             return gr.FileExplorer(root_dir=here / "inputs/fasta"), gr.FileExplorer(root_dir=here / "inputs/config")
         
         btn_refresh.click(update_file_explorer, outputs=[inp1,inp2]).then(update_file_explorer_2, outputs=[inp1, inp2])
                       
-        out = Molecule3D(label="Plot the 3D Molecule", reps=reps)
-        btn = gr.Button("Run")
-        btn.click(fn=compute_Chai1, inputs=[inp1 , inp2], outputs=[out])
+        #out = Molecule3D(label="Plot the 3D Molecule", reps=reps)
+        out = gr.DataFrame(
+            headers=["Model Index", "Aggregate Score", "PTM", "IPTM", "CIF File"],
+            datatype=["number", "number", "number", "number", "str"],
+            label="Inference Results sorted by Aggregate Score",
+            visible=True,
+        )
+        out2 = Molecule3D(label="Plot the 3D Molecule", reps=reps)
+        
+        btn = gr.Button("Run Simulation")
+        btn.click(fn=compute_Chai1, inputs=[inp1 , inp2], outputs=[out]).then(
+            fn=plot_protein, 
+            inputs=out, 
+            outputs=out2
+        )
+    
+    
+    with gr.Tab("Show protein from a cif file 💻"):     
+        
+        gr.Markdown(
+        """
+        ## Plot a 3D structure from a CIF file
+        """)
         
+        cif_input = gr.File(label="Input CIF file", file_count='single')
+        cif_output = Molecule3D(label="Plot the 3D Molecule", reps=reps)        
+        cif_input.change(fn=show_cif_file, inputs=cif_input, outputs=cif_output)
 
 # Launch both the Gradio web interface and the MCP server
 if __name__ == "__main__":

introduction_page.md

@@ -0,0 +1,106 @@
+<style>
+code[class*="language-bash"], pre[class*="language-bash"] {
+  background: #fff !important;
+}
+</style>
+
+# Stakes
+
+The industry is being deeply changed by the development of LLMs and the recent possibilities to provide them access to external tools. For years, companies have used simulation tools to accelerate and reduce the cost of product development. One of the main challenges in the coming years will be to create agents that can set up, run, and process simulations to further accelerate innovation.
+
+# Objective
+
+This project is a first step in creating AI agents that perform simulations on existing software. Key domains include:
+- **CFD** (Computational Fluid Dynamics) simulations
+- **Biology** (Protein Folding, Molecular Dynamics, etc.)
+- **Neural network applications**
+
+This project focuses on protein folding, but the same principles can be applied to other domains. In particular it uses [Chai-1](https://www.chaidiscovery.com/blog/introducing-chai-1), which is a multi-modal foundation model for molecular structure prediction, performing at state-of-the-art levels across a variety of benchmarks. Chai-1 enables unified prediction of proteins, small molecules, DNA, RNA, glycosylations, and more. Using Chai-1 on Modal is a great example of running folding simulations.
+
+Industrial computations are often performed on HPC clusters with large resources, so simulations typically run on separate servers. The LLM must be able to access simulation results to provide complete answers to users. To this purpose, [Modal](https://modal.com/), a serverless platform that provides a simple way to run any application with the latest CPU and GPU hardware will be used.
+
+[Demonstration](https://www.youtube.com/watch?v=P9cAKxJ9Zh8)
+
+---
+
+# Instructions
+
+<div style="background-color:#f5f5f5; border-radius:8px; padding:18px 24px; margin-bottom:24px; border:1px solid #cccccc;">
+
+### 1. <span style="color:#2563eb;">(Optional) Create your JSON configuration file</span>
+<small>Default configuration is available if you skip this step.</small>
+
+- Set your simulation parameters and generate the JSON config file. A unique identifier will be assigned (e.g., `chai_{run_id}_config.json`).
+- **Parameters:**
+  - <b>Number of diffusion time steps:</b> 1 to 500
+  - <b>Number of trunk recycles:</b> 1 to 5
+  - <b>Seed:</b> 1 to 100
+  - <b>ESM_embeddings:</b> Include or not
+  - <b>MSA_server:</b> Include or not
+
+### 2. <span style="color:#2563eb;">(Optional) Upload a FASTA file with your molecule sequence</span>
+<small>Default FASTA files are available if you skip this step.</small>
+
+- Write your FASTA content and create the file. A unique identifier will be assigned (e.g., `chai_{run_id}_input.fasta`).
+- <b style="color:#b91c1c;">Warning:</b> The header must be well formatted for Chai1 to process it.
+
+**FASTA template:**
+```fasta
+>{molecule_type}|{molecule_name}
+Sequence (for protein/RNA/DNA) or SMILES for ligand
+```
+
+**Accepted  molecule types:** 
+ `protein`/ `rna`/  `dna` / `ligand`
+
+**Default input (provided by Chai1):**
+```fasta
+>protein|name=example-of-long-protein
+AGSHSMRYFSTSVSRPGRGEPRFIAVGYVDDTQFVRFDSDAASPRGEPRAPWVEQEGPEYWDRETQKYKRQAQTDRVSLRNLRGYYNQSEAGSHTLQWMFGCDLGPDGRLLRGYDQSAYDGKDYIALNEDLRSWTAADTAAQITQRKWEAAREAEQRRAYLEGTCVEWLRRYLENGKETLQRAEHPKTHVTHHPVSDHEATLRCWALGFYPAEITLTWQWDGEDQTQDTELVETRPAGDGTFQKWAAVVVPSGEEQRYTCHVQHEGLPEPLTLRWEP
+
+>protein|name=example-of-short-protein
+AIQRTPKIQVYSRHPAENGKSNFLNCYVSGFHPSDIEVDLLKNGERIEKVEHSDLSFSKDWSFYLLYYTEFTPTEKDEYACRVNHVTLSQPKIVKWDRDM
+
+>protein|name=example-peptide
+GAAL
+
+>ligand|name=example-ligand-as-smiles
+CCCCCCCCCCCCCC(=O)O
+```
+<small>For a peptide, use `protein` as the molecule type.</small>
+
+**Other example:**
+```fasta
+>protein|lysozyme
+MNIFEMLRIDEGLRLKIYKDTEGYYTIGIGHLLTKSPDLNAAKSELDKAIGRNCNGVITKDEAEKLFNQDVDAAVRGILRNAKLKPVYDSLDAVRRCAAINQVFQMGETGVAGFTNSLRMLQQKRWDEAAVNLAKSRWYNQTPDRAKRVITTFRTGTWDAYKNL
+```
+### 3. <span style="color:#2563eb;">Select your config and FASTA files</span>
+<small>Files are stored in your working directory as you create them.</small>
+
+### 4. <span style="color:#2563eb;">Click the "Run" button to start the simulation</span>
+
+### 5. <span style="color:#2563eb;">View the 3D visualization of your molecule</span>
+</div>
+
+## Simulation parameters choice       
+If no config or fasta files are created, default values are chosen:
+- chai1_default_input.fasta
+- chai1_quick_inference.json
+
+The files content is diplayed at the bottom of the page.
+The default json configuration makes the computation fast (about 2min) but results can be disappointing. 
+Please use chai1_default_inference.json to have a wonderful protein 😃.
+
+- chai1_quick_inference.json
+```json
+{
+    "num_trunk_recycles": 1,
+    "num_diffn_timesteps": 10,
+    "seed": 42,
+    "use_esm_embeddings": true
+    "use_msa_server": false
+}
+```
+
+# Contact
+For any issues or questions, please contact the developer or refer to the documentation.