unify modal with tools

main.py

@@ -5,22 +5,13 @@ import modal
 import sys
 import subprocess
 import time
-# import litellm
+from .tools.meta_yml_tools import fetch_meta_yml,get_meta_yml_file, extract_tools_from_meta_json, extract_information_from_meta_json, extract_module_name_description
 
-# define modal app
-app = modal.App("agent-ontology")
-
-# define ollama image for modal
-OLLAMA_IMAGE = (
+# Define the custom image
+ollama_image = (
     modal.Image.debian_slim()
-    # pkill/pgrep come from procps
-    .apt_install(
-        "curl", "gnupg", "software-properties-common",
-        "procps"               # ← adds pkill, pgrep, ps …
-    )
-    # install Ollama
+    .apt_install("curl", "gnupg", "software-properties-common", "procps")
     .run_commands("curl -fsSL https://ollama.com/install.sh | sh")
-    # spin up daemon, pull the model, shut daemon down
     .run_commands(
         "bash -c 'ollama serve >/dev/null 2>&1 & "
         "PID=$!; "
@@ -29,7 +20,6 @@ OLLAMA_IMAGE = (
         "ollama pull qwen3:0.6b && "
         "kill $PID'"
     )
-    # python deps
     .pip_install(
         "fastmcp>=2.6.1",
         "gradio[mcp]>=5.0.0",
@@ -40,6 +30,9 @@ OLLAMA_IMAGE = (
     )
 )
 
+# Initialize the Modal app with the custom image
+app = modal.App("agent-ontology", image=ollama_image)
+
 def chat_with_agent(message, history):
     """ Function to handle chat messages and interact with the agent.
     This function creates a new MCP connection for each request, allowing the agent to use tools from the MCP server.
@@ -73,33 +66,62 @@ def chat_with_agent(message, history):
             
     except Exception as e:
         return f"❌ Error: {e}\nType: {type(e).__name__}"
+    
+def run_multi_agent(module_name): 
+    meta_yml = get_meta_yml_file(module_name=module_name)
+    module_info = extract_module_name_description(meta_file=meta_yml)
+    module_tools = extract_tools_from_meta_json(meta_file=meta_yml)
+    # TODO: agent to choose the right tool
+    # Only call the agent if there is more than one tool, otherwise get the first name
+    first_prompt = f"""
+        The module {module_info[0]} with desciption '{module_info[1]}' contains a series of tools. 
+        Find the tool that best describes the module. Return only one tool. Return the name. 
+        This is the list of tools:
+        {"\n\t".join(f"{tool[0]}: {tool[1]}" for tool in module_tools)}
+    """
+    tool_name = "fastqc" # this would be the answer of the first agent
+    meta_info = extract_information_from_meta_json(meta_file=meta_yml, tool_name=tool_name)
+    return(meta_info)
 
-def run_agent():
+def run_interface():
     """ Function to run the agent with a Gradio interface.
     This function sets up the Gradio interface and launches it.
     """
-    demo = gr.ChatInterface(
-        fn=chat_with_agent,
-        type="messages",
-        examples=["can you extract input/output metadata from fastqc nf-core module ?"],
-        title="Agent with MCP Tools (Per-Request Connection)",
-        description="This version creates a new MCP connection for each request."
-    )
+    # create the Gradio interface
+    with gr.Blocks() as demo:
+        gr.Markdown("### 🔍 Update an nf-core module `meta.yml` file by adding EDAM ontology terms.")
+
+        # create the input textbox for the nf-core module name
+        module_input = gr.Textbox(label="nf-core Module Name", placeholder="e.g. fastqc")
+
+        # create the button to fetch the meta.yml file
+        fetch_btn = gr.Button("Update meta.yml")
+
+        # create the output textbox for the meta.yml content and a download button
+        meta_output = gr.Textbox(label="meta.yml content", lines=20)
+        download_button = gr.File(label="Download meta.yml")
+
+        # set the function to run when the button is clicked
+        fetch_btn.click(
+            fn=run_multi_agent,  # TODO: change to final function
+            inputs=module_input,
+            outputs=[meta_output]
+        )
+    
     demo.launch(share=True)
 
-@app.function(image=OLLAMA_IMAGE, gpu="A10G", timeout=2400)
+@app.function(keep_warm=1, gpu="A10G", timeout=2400)
 def main_remote():
     # spin up Ollama daemon in the background
     server = subprocess.Popen(["ollama", "serve"])
     time.sleep(6) # give it a moment to bind :11434
     try:
-        # litellm._turn_on_debug()
-        run_agent()
+        run_interface()
     finally:
         server.terminate()
 
 def main_local():
-    run_agent()
+    run_interface()
 
 if __name__ == "__main__":
     # check if it is modal running the script or python running the script

tools/meta_yml_tools.py

@@ -0,0 +1,122 @@
+import requests
+import json
+import yaml
+
+# TODO: placeholder function
+def fetch_meta_yml(module_name):
+    # Adjust the URL or path to your actual source of nf-core modules
+    base_url = f"https://raw.githubusercontent.com/nf-core/modules/refs/heads/master/modules/nf-core/{module_name}/meta.yml"
+    try:
+        response = requests.get(base_url)
+        response.raise_for_status()
+        content = response.text
+
+        # Save for download
+        with open("meta.yml", "w") as f:
+            f.write(content)
+
+        return content, "meta.yml"
+    except Exception as e:
+        return f"Error: Could not retrieve meta.yml for module '{module_name}'\n{e}", None
+
+def get_meta_yml_file(module_name: str) -> dict:
+    """
+    Access the nf-core/modules repository and return the meta.yml file of the given module.
+    
+    Args:
+        module_name (str): The name of the module to get the meta.yml file for. 
+                            The module_name must be provided in the format <tool>_<subtool> or <tool>/<subtool> or <tool> <subtool>.
+                            The subtool is optional.
+                            For example, "bwa_align" or "fastqc" or "bwa align" or "bwa/align".
+    Returns:
+        dict: The meta.yml file of the given module in json/yaml format as a dictionary.
+    """
+    if "_" in module_name:
+        tool, subtool = module_name.split("_")
+    elif "/" in module_name:
+        tool, subtool = module_name.split("/")
+    elif " " in module_name:
+        tool, subtool = module_name.split(" ")
+    else:
+        tool, subtool = module_name, ""
+
+    if subtool:
+        url = f"https://raw.githubusercontent.com/nf-core/modules/refs/heads/master/modules/nf-core/{tool}/{subtool}/meta.yml"
+    else:
+        url = f"https://raw.githubusercontent.com/nf-core/modules/refs/heads/master/modules/nf-core/{tool}/meta.yml"
+    try:
+        response = requests.get(url)
+        response.raise_for_status()  # Raise an error for bad status codes
+        return yaml.safe_load(response.text)
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"An error occurred while connecting to the URL: {url}. Error message: {e}")
+
+def extract_module_name_description(meta_file: dict) -> list:
+    """
+    Extract the name and description of the module from the meta.yml file.
+
+    Args:
+        meta_file (str): The content of the module meta.yml file in json format.
+
+    Returns:
+        list: A list containing two elements, the module name and the module description.
+    """
+    name = meta_file.get("name", "")
+    description = meta_file.get("description", "")
+    return [name, description]
+
+def extract_tools_from_meta_json(meta_file: dict) -> list[list]:
+    """
+    Extract the tools and description from the meta.yml file.
+
+    Args:
+        meta_file (str): The content of the module meta.yml file in json format.
+
+    Returns:
+        list: A list of lists. Each element of the list is one tool, the sub-list contains two elements, the name and description of the tool.
+    """
+    module_tools = []
+    tools_list = meta_file.get("tools", [])
+    for tool in tools_list:
+        name = list(tool.keys())[0]
+        description = tool[name].get("description", "")
+        module_tools.append([name, description])
+    return module_tools
+
+def extract_information_from_meta_json(meta_file: dict, tool_name: str) -> dict:
+    """
+    Extract information metadata from an nf-core module meta.yml file.
+    Information extracted:
+        - inputs
+        - outputs
+        - homepage URL
+        - documentation URL
+        - bio.tools ID
+        
+
+    Args:
+        meta_file (str): The content of the module meta.yml file in json format.
+        tool_name (str): The name of the tool to extract information for.
+
+    Returns:
+        dict: A dictionary with the extracted metadata.
+            Each file or term can also contain additional metadata like 'description' or 'type'.
+
+    Example output:
+        {
+            "inputs": [...],
+            "outputs": [...],
+            "homepage": "https://www.bioinformatics.babraham.ac.uk/projects/fastqc/",
+            "documentation": "https://www.bioinformatics.babraham.ac.uk/projects/fastqc/Help/",
+            "bio_tools_id": "biotools:fastqc"
+        }
+    """
+    inputs = meta_file.get("input", [])
+    outputs = meta_file.get("output", [])
+    for tool in meta_file.get("tools", []):
+        if list(tool.keys())[0] == tool_name:
+            homepage_url = tool.get("homepage", "")
+            documentation_rul = tool.get("documentation", "")
+            bio_tools_id = tool.get("identifier", "")
+        print("Extracted metadata information from nf-core module meta.yml")
+    return {"inputs": inputs, "outputs": outputs, "homepage": homepage_url, "documentation": documentation_rul, "bio_tools_id": bio_tools_id}