aurelian 0.1.0__py3-none-any.whl

aurelian/agents/robot/robot_ontology_agent.py

@@ -0,0 +1,139 @@
+"""
+Agent for creating ROBOT templates and compiling to ontologies.
+"""
+from dataclasses import dataclass, field
+from typing import List, Dict
+
+from aurelian.agents.filesystem.filesystem_tools import inspect_file, download_url_as_markdown, list_files
+from aurelian.agents.robot.robot_config import RobotDependencies
+from aurelian.agents.robot.robot_tools import write_and_compile_template, fetch_documentation
+from aurelian.utils.async_utils import run_sync
+from aurelian.utils.search_utils import web_search
+from pydantic_ai import Agent, RunContext, Tool
+
+from aurelian.dependencies.workdir import WorkDir, HasWorkdir
+
+SYSTEM = """
+Background:
+
+Your job is to iteratively build an ontology via *robot templates*,
+These are tabular data (CSV syntax) with a special header that compiles to OWL.
+
+For example, if the request is for an animals ontology, you could start with a CSV with columns Name, ParentTaxon, Eats, 
+with rows filled out with some example animals.
+
+The main tool you will use is `write_and_compile_template` which writes the the template content to
+a local file after compiling to OWL. This also takes a list of ontologies to import, which
+should also be on the file system.
+
+Sometimes you may need to work with multiple dependent ontologies. For example, if you have a vehicle class
+hierarchy in `vehicles.csv` and parts in `parts.csv`, and vehicles depends on parts, you would first iterate
+on `parts.csv` (e.g. calling `write_and_compile_template`, with no imports), then write vehicles using
+`write_and_compile_template` with `['parts.csv']` as the dependencies/imports.
+
+## Robot template CSV structure:
+
+Robot template files have an additional metadata row below the header row. This is called the "template row". It specifies how each column maps to OWL. Typical values will be "ID" for the unique identifier, LABEL for the name, "SC %" for the parent class. Consult the docs for details. Note that this is always beneath the main header row. This can seem a bit duplicative, but that's OK. An example might be:
+
+identifier,name,parent,synonyms
+ID,LABEL,SC %,A oboInOwl:hasExactSynonym
+ANIMAL:1,chicken,aves,Gallus gallus|chick
+
+The first row is a normal header with human-friendly columns. The 2nd is the robot template row. After that are the usual data rows.
+
+Here "A oboInOwl:hasExactSynonym" in the template row for "synonyms" indicate this column should be interpreted as an owl annotation using that property. Generally the value for annotations is literals/text.
+
+Another common piece of metadata is definitions. For OBO ontologies, IAO must be used here. For non-OBO ontologies people may want to use skos
+
+Some ontologies may need to use other relationships. For part-of parents, use "'part of' some %" (this means that the class indicated by the ID is part-of some X, where X is the value in the part-of column). Use other relationships as appropriate. If you are unclear about the semantics, then consult the docs. You can also work through the docs with the user.
+
+Note that any terms referenced as parents or in logical axioms such as part-of should be in the ontology, so make sure they have rows in the CSV.  It's OK to use the label. For example:
+
+identifier,primary_name,parent,madeOf
+ID,LABEL,SC %,SC 'made of' some %
+VON:1,vehicle,,
+VON:2.car,vehicle,wheel|chassis
+VON:3,wheel,car part,
+VON:4,chassis,car part,
+
+If in doubt, use "A <propertyName>" for metadata and "SC '<relationName>' some %" for logical relationships / graph edges.
+
+If your working dir doesn't contain any object or annotation properties you can make them in a seperate
+imported ontology, TYPE is useful for determining the OWL type, for example:
+
+```
+ID,Label,Type,Definition
+ID,LABEL,TYPE,A IAO:0000115
+IAO:0000115,definition,owl:AnnotationProperty
+BFO:0000050,part_of,owl:ObjectProperty
+```
+
+If you need any more detailed documentation, you can fetch it with `fetch_documentation`
+
+You can look at files with `inspect_file`
+
+Use scientific language as far as possible. For IDs, these should be numeric curies unless the user requests otherwise. If the user wants to substitute actual ontology term IDs for these, use lookup_curies_get_lookup_get 
+"""
+
+
+
+
+robot_ontology_agent = Agent(
+    model="openai:gpt-4o",
+    deps_type=RobotDependencies,
+    system_prompt=SYSTEM,
+    tools=[
+        Tool(write_and_compile_template, max_retries=2),
+        Tool(fetch_documentation),
+        Tool(inspect_file),
+        Tool(list_files),
+        Tool(download_url_as_markdown),
+    ]
+)
+
+
+@robot_ontology_agent.system_prompt
+def include_templates_in_prompt(ctx: RunContext[RobotDependencies]) -> str:
+    files_names = ctx.deps.workdir.list_file_names()
+    s = "Working directory files/templates:"
+    if files_names:
+        for f in files_names:
+            s += f"{f}\n---"
+            s += ctx.deps.workdir.read_file(f)
+            s += "\n"
+    return s
+
+
+@robot_ontology_agent.system_prompt
+def include_prefixes_in_prompt(ctx: RunContext[RobotDependencies]) -> str:
+    pmap = ctx.deps.prefix_map
+    return f"Prefixes: {pmap}"
+
+
+
+
+
+
+def chat(workdir: str, **kwargs):
+    import gradio as gr
+    deps = RobotDependencies()
+    deps.workdir.location = workdir
+
+    def get_info(query: str, history: List[str]) -> str:
+        print(f"QUERY: {query}")
+        print(f"HISTORY: {history}")
+        if history:
+            query += "## History"
+            for h in history:
+                query += f"\n{h}"
+        result = run_sync(lambda: robot_ontology_agent.run_sync(query, deps=deps, **kwargs))
+        return result.data
+
+    return gr.ChatInterface(
+        fn=get_info,
+        type="messages",
+        title="robot AI Assistant",
+        examples=[
+            ["Create an ontology of snacks"],
+        ]
+    )

aurelian/agents/robot/robot_tools.py

@@ -0,0 +1,50 @@
+from typing import Optional, List
+
+from pydantic_ai import RunContext, ModelRetry
+
+from aurelian.agents.robot.assets import ROBOT_ONTOLOGY_AGENT_CONTENTS_DIR
+from aurelian.agents.robot.robot_config import RobotDependencies
+from aurelian.utils.robot_ontology_utils import run_robot_template_command
+
+
+async def write_and_compile_template(ctx: RunContext[RobotDependencies], template: str, save_to_file: str= "core.csv", import_ontologies: Optional[List[str]] = None) -> str:
+    """
+    Adds a template to the file system and compile it to OWL
+
+    Args:
+        ctx: context
+        template: robot template as string. Do not truncate, always pass the whole template, including header.
+        save_to_file: file name to save the templates to. Defaults to core.csv. Only written if file compiles to OWL
+        import_ontologies: list of ontologies to import. These should be files in the working directory.
+
+    Returns:
+
+    """
+    print(f"Validating template: {template}")
+    try:
+        ctx.deps.workdir.write_file(save_to_file, template)
+        output_path = run_robot_template_command(
+            ctx.deps.workdir,
+            save_to_file,
+            import_ontologies=import_ontologies,
+            prefix_map=ctx.deps.prefix_map,
+            output_path=None,
+        ),
+        if save_to_file and template:
+            ctx.deps.workdir.write_file(save_to_file, template)
+    except Exception as e:
+        raise ModelRetry(f"Template does not compile: {e}")
+    return f"Template compiled to {output_path}"
+
+
+async def fetch_documentation(ctx: RunContext[RobotDependencies]) -> str:
+    """
+    Fetch the documentation for the robot ontology agent.
+
+    Args:
+        ctx: context
+
+    Returns:
+        str: documentation
+    """
+    return open(ROBOT_ONTOLOGY_AGENT_CONTENTS_DIR / "template.md").read()

aurelian/agents/talisman/__init__.py

@@ -0,0 +1,3 @@
+"""
+Talisman agent package for advanced gene analysis using UniProt and NCBI Entrez.
+"""

aurelian/agents/talisman/__main__.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+"""
+Main entry point to run the talisman agent.
+"""
+import os
+import sys
+from pydantic_ai import chat
+
+# Add the parent directory to the path for absolute imports
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../../../")))
+
+from aurelian.agents.talisman.talisman_agent import talisman_agent
+from aurelian.agents.talisman.talisman_config import get_config
+
+if __name__ == "__main__":
+    config = get_config()
+    chat(talisman_agent, deps=config)

aurelian/agents/talisman/cli.py

@@ -0,0 +1,70 @@
+"""
+CLI interface for the talisman agent.
+This may not be in the original code, but let's add it to make sure it's properly configured.
+"""
+import logging
+import re
+from pydantic_ai import RunContext
+
+from aurelian.agents.talisman.talisman_config import TalismanConfig
+from aurelian.agents.talisman.talisman_tools import GeneSetAnalysis, FunctionalTerm, GeneSummary
+
+def format_talisman_output(result):
+    """Format the talisman output to ensure it always has all three sections."""
+    logging.info("Post-processing talisman output")
+    
+    # Check if output already has proper sections
+    has_narrative = re.search(r'^\s*##\s*Narrative', result, re.MULTILINE) is not None
+    has_functional_terms = re.search(r'^\s*##\s*Functional Terms Table', result, re.MULTILINE) is not None
+    has_gene_summary = re.search(r'^\s*##\s*Gene Summary Table', result, re.MULTILINE) is not None
+    
+    # If all sections are present, return as is
+    if has_narrative and has_functional_terms and has_gene_summary:
+        return result
+    
+    # Need to reconstruct the output
+    # Extract gene summary table if it exists
+    gene_table_match = re.search(r'^\s*##\s*Gene Summary Table\s*\n(.*?)(?=$|\n\n|\Z)', 
+                                result, re.MULTILINE | re.DOTALL)
+    
+    if gene_table_match:
+        gene_table = gene_table_match.group(0)
+        
+        # Extract existing text that might be a narrative
+        narrative_text = result.replace(gene_table, '').strip()
+        
+        # Create a proper narrative section if missing
+        if not has_narrative and narrative_text:
+            narrative_section = "## Narrative\n" + narrative_text + "\n\n"
+        else:
+            narrative_section = "## Narrative\nThese genes may have related functions as indicated in the gene summary table.\n\n"
+        
+        # Create a functional terms section if missing
+        if not has_functional_terms:
+            # Extract gene IDs from the gene table
+            gene_ids = []
+            for line in gene_table.split('\n'):
+                if '|' in line and not line.strip().startswith('|--') and not 'ID |' in line:
+                    parts = line.split('|')
+                    if len(parts) > 1:
+                        gene_id = parts[1].strip()
+                        if gene_id and gene_id != 'ID':
+                            gene_ids.append(gene_id)
+            
+            # Create a simple functional terms table
+            functional_terms = "## Functional Terms Table\n"
+            functional_terms += "| Functional Term | Genes | Source |\n"
+            functional_terms += "|-----------------|-------|--------|\n"
+            functional_terms += f"| Gene set | {', '.join(gene_ids)} | Analysis |\n\n"
+        else:
+            # Find and extract existing functional terms section
+            ft_match = re.search(r'^\s*##\s*Functional Terms Table\s*\n(.*?)(?=^\s*##\s*|\Z)', 
+                                result, re.MULTILINE | re.DOTALL)
+            functional_terms = ft_match.group(0) if ft_match else ""
+        
+        # Reconstruct the output with all sections
+        formatted_output = "# Gene Set Analysis\n\n" + narrative_section + functional_terms + gene_table
+        return formatted_output
+    
+    # If no gene table was found, return the original result
+    return result

aurelian/agents/talisman/run_talisman.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+"""
+Standalone script to run the talisman agent directly.
+"""
+import os
+import sys
+from pydantic_ai import chat
+
+# Add the src directory to the path for imports
+src_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../../../"))
+sys.path.insert(0, src_dir)
+
+from aurelian.agents.talisman.talisman_agent import talisman_agent
+from aurelian.agents.talisman.talisman_config import get_config
+
+if __name__ == "__main__":
+    config = get_config()
+    chat(talisman_agent, deps=config)

aurelian/agents/talisman/talisman_agent.py

@@ -0,0 +1,143 @@
+"""
+Agent for working with gene information using the UniProt API and NCBI Entrez.
+Provides structured information in the form of Narrative, Functional Terms Table, and Gene Summary Table.
+"""
+from pydantic_ai import Agent
+
+from .talisman_config import TalismanConfig, get_config
+from .talisman_tools import (
+    get_gene_description, 
+    get_gene_descriptions, 
+    get_genes_from_list, 
+    analyze_gene_set
+)
+
+# System prompt for the Talisman agent
+TALISMAN_SYSTEM_PROMPT = """
+You are a helpful assistant that specializes in providing gene information using both UniProt and NCBI Entrez.
+You can retrieve gene descriptions for single gene IDs or lists of multiple gene IDs, and analyze gene sets to identify functional relationships.
+
+You can:
+- Get a description for a single gene using its identifier
+- Get descriptions for multiple genes using a list of identifiers
+- Parse a string containing multiple gene identifiers in various formats
+- Analyze sets of genes to identify biological relationships and shared properties
+
+Gene identifiers can be:
+- UniProt accession numbers (e.g., P12345, Q934N0)
+- Gene symbols (e.g., INS, TP53, mmoX)
+- Gene names
+- Ensembl IDs (e.g., ENSG00000139618)
+- NCBI protein IDs (e.g., 8YJT_C2)
+
+IMPORTANT: The system handles both gene symbols and UniProt identifiers intelligently:
+1. When a gene symbol is provided, the system will:
+   - First attempt to look up the corresponding UniProt protein accession
+   - Search UniProt for detailed information
+   - Fall back to NCBI Entrez if the gene is not found in UniProt
+
+2. When a UniProt ID is provided, the system will:
+   - Directly retrieve the information from UniProt
+   - Fall back to NCBI Entrez if needed
+
+3. When a protein ID is provided, the system will:
+   - Search the protein database in NCBI Entrez
+   - Return detailed protein information
+
+This multi-database approach ensures comprehensive coverage of gene and protein information.
+
+When returning gene information, present it in a clear, organized manner with:
+- Gene name and symbol
+- Description of gene function
+- Organism information when available
+- Disease associations if relevant
+- Source database (UniProt, NCBI, or both)
+
+For multiple genes, organize the results in a table format for easy readability.
+
+For gene set analysis, you will receive a detailed summary of:
+- Shared biological processes these genes may participate in
+- Potential protein-protein interactions or functional relationships
+- Common cellular localization patterns
+- Involvement in similar pathways
+- Coordinated activities or cooperative functions
+- Any disease associations that multiple genes in this set share
+
+The analysis will cover multiple types of relationships:
+- Functional relationships
+- Pathway relationships
+- Regulatory relationships
+- Localization patterns
+- Physical interactions
+- Genetic interactions
+
+For gene set analysis, your output MUST always include three distinct sections:
+
+1. First, a "## Narrative" section providing a concise explanation of the functional and categorical relationships between the genes. This should:
+   - Prioritize explanations involving most or all genes in the set
+   - Refer to specific subsets of genes when discussing specialized functions
+   - Highlight the most significant shared pathways, processes, or disease associations
+   - Be clear, concise, and focused on biological meaning
+
+2. Second, a "## Functional Terms Table" that presents key functional terms in a tabular format with these columns:
+   - Functional Term: The biological term or concept (e.g., DNA repair, kinase activity)
+   - Genes: The genes associated with this term (comma-separated list)
+   - Source: The likely source database or ontology (e.g., GO-BP, KEGG, Reactome, GO-MF, GO-CC, Disease)
+
+The functional terms should include various types:
+- Gene Ontology biological process terms (e.g., DNA repair, oxidative phosphorylation)
+- Molecular function terms (e.g., kinase activity, DNA binding)
+- Cellular component/localization terms (e.g., nucleus, plasma membrane)
+- Pathway names (e.g., glycolysis, MAPK signaling)
+- Disease associations (if relevant)
+- Structural and functional domains/motifs (if relevant)
+
+Example of Functional Terms Table:
+## Functional Terms Table
+| Functional Term | Genes | Source |
+|-----------------|-------|--------|
+| DNA damage response | BRCA1, BRCA2, ATM | GO-BP |
+| Homologous recombination | BRCA1, BRCA2 | Reactome |
+| Tumor suppression | BRCA1, BRCA2, ATM | Disease |
+| Nuclear localization | BRCA1, BRCA2, ATM | GO-CC |
+| Kinase activity | ATM | GO-MF |
+| PARP inhibitor sensitivity | BRCA1, BRCA2, PARP1 | Pathway |
+
+3. Third, a "## Gene Summary Table" with a markdown table summarizing the genes analyzed, 
+with the following columns in this exact order:
+   - ID: The gene identifier (same as Gene Symbol)
+   - Annotation: Genomic coordinates or accession with position information
+   - Genomic Context: Information about the genomic location (chromosome, plasmid, etc.)
+   - Organism: The organism the gene belongs to
+   - Description: The protein/gene function description
+
+Example of Gene Summary Table:
+## Gene Summary Table
+| ID | Annotation | Genomic Context | Organism | Description |
+|-------------|-------------|----------|----------------|------------|
+| BRCA1 | NC_000017.11 (43044295..43125483) | Chromosome 17 | Homo sapiens | Breast cancer type 1 susceptibility protein |
+| BRCA2 | NC_000013.11 (32315474..32400266) | Chromosome 13 | Homo sapiens | Breast cancer type 2 susceptibility protein |
+| ATM | NC_000011.10 (108222484..108369102) | Chromosome 11 | Homo sapiens | ATM serine/threonine kinase |
+| PARP1 | NC_000001.11 (226360251..226408516) | Chromosome 1 | Homo sapiens | Poly(ADP-ribose) polymerase 1 |
+
+For bacterial genes, the table format would be:
+| ID | Annotation | Genomic Context | Organism | Description |
+|-------------|-------------|----------|----------------|------------|
+| invA | NC_003197.2 (3038407..3040471, complement) | Chromosome | Salmonella enterica | Invasion protein |
+| DVUA0001 | NC_005863.1 (699..872, complement) | Plasmid pDV | Desulfovibrio vulgaris str. Hildenborough | Hypothetical protein |
+
+Use this information to help researchers understand the potential functional relationships between genes.
+"""
+
+# Create the agent with the system prompt
+talisman_agent = Agent(
+    model="openai:gpt-4o",
+    system_prompt=TALISMAN_SYSTEM_PROMPT,
+    deps_type=TalismanConfig,
+)
+
+# Register the tools with the agent
+talisman_agent.tool(get_gene_description)
+talisman_agent.tool(get_gene_descriptions)
+talisman_agent.tool(get_genes_from_list)
+#talisman_agent.tool(analyze_gene_set)

aurelian/agents/talisman/talisman_config.py

@@ -0,0 +1,66 @@
+"""
+Configuration for the Talisman agent.
+"""
+from dataclasses import dataclass, field
+import os
+from typing import Any, Dict, Optional
+
+from bioservices import UniProt
+from bioservices.eutils import EUtils as NCBI
+
+from aurelian.dependencies.workdir import HasWorkdir, WorkDir
+
+
+@dataclass
+class TalismanConfig(HasWorkdir):
+    """Configuration for the Talisman agent."""
+
+    # Options for the bioservices UniProt client
+    uniprot_client_options: Dict[str, Any] = field(default_factory=dict)
+    
+    # Options for the bioservices NCBI client
+    ncbi_client_options: Dict[str, Any] = field(default_factory=dict)
+    
+    # OpenAI API key for LLM-based analysis
+    openai_api_key: Optional[str] = None
+    
+    # Model to use for gene set analysis
+    model_name: str = "gpt-4o"
+
+    def __post_init__(self):
+        """Initialize the config with default values."""
+        # Initialize with default options if none provided
+        if self.uniprot_client_options is None or len(self.uniprot_client_options) == 0:
+            self.uniprot_client_options = {"verbose": False}
+            
+        if self.ncbi_client_options is None or len(self.ncbi_client_options) == 0:
+            self.ncbi_client_options = {"verbose": False, "email": "MJoachimiak@lbl.gov"}
+        
+        # Initialize the workdir if not already set
+        if self.workdir is None:
+            self.workdir = WorkDir()
+        
+        # Try to get OpenAI API key from environment if not provided
+        if self.openai_api_key is None:
+            import os
+            self.openai_api_key = os.environ.get("OPENAI_API_KEY")
+
+    def get_uniprot_client(self) -> UniProt:
+        """Get a configured UniProt client."""
+        return UniProt(**self.uniprot_client_options)
+        
+    def get_ncbi_client(self) -> NCBI:
+        """Get a configured NCBI client."""
+        return NCBI(**self.ncbi_client_options)
+
+
+def get_config() -> TalismanConfig:
+    """Get the Talisman configuration from environment variables or defaults."""
+    workdir_path = os.environ.get("AURELIAN_WORKDIR", None)
+    workdir = WorkDir(location=workdir_path) if workdir_path else None
+    
+    return TalismanConfig(
+        workdir=workdir,
+        uniprot_client_options={"verbose": False},
+        ncbi_client_options={"verbose": False}
+    )

aurelian/agents/talisman/talisman_gradio.py

@@ -0,0 +1,50 @@
+"""
+Gradio interface for the Talisman agent.
+"""
+from typing import List, Optional
+
+import gradio as gr
+
+from aurelian.agents.talisman.talisman_agent import talisman_agent
+from aurelian.agents.talisman.talisman_config import TalismanConfig
+from aurelian.utils.async_utils import run_sync
+
+
+def chat(deps: Optional[TalismanConfig] = None, **kwargs):
+    """
+    Initialize a chat interface for the Talisman agent.
+    
+    Args:
+        deps: Optional dependencies configuration
+        **kwargs: Additional arguments to pass to the agent
+        
+    Returns:
+        A Gradio chat interface
+    """
+    if deps is None:
+        deps = TalismanConfig()
+
+    def get_info(query: str, history: List[str]) -> str:
+        print(f"QUERY: {query}")
+        print(f"HISTORY: {history}")
+        if history:
+            query += "## History"
+            for h in history:
+                query += f"\n{h}"
+        result = run_sync(lambda: talisman_agent.run_sync(query, deps=deps, **kwargs))
+        return result.data
+
+    return gr.ChatInterface(
+        fn=get_info,
+        type="messages",
+        title="Talisman Gene Analysis Assistant",
+        examples=[
+            ["Get description for TP53"],
+            ["Get information about the BRCA1 gene"],
+            ["Get descriptions for multiple genes: INS, ALB, APOE"],
+            ["What is the function of KRAS?"],
+            ["Analyze the relationship between TP53 and MDM2"],
+            ["Analyze these genes and their functional relationships: BRCA1, BRCA2, ATM, PARP1"],
+            ["Get descriptions for ENSG00000139618, ENSG00000141510"]
+        ]
+    )

aurelian/agents/talisman/talisman_mcp.py

@@ -0,0 +1,75 @@
+"""
+MCP tools for retrieving gene information using the UniProt API and NCBI Entrez.
+"""
+import os
+
+from mcp.server.fastmcp import FastMCP
+
+from aurelian.agents.talisman.talisman_agent import TALISMAN_SYSTEM_PROMPT
+from aurelian.agents.talisman.talisman_config import TalismanConfig, get_config
+from aurelian.agents.talisman.talisman_tools import (
+    get_gene_description,
+    get_gene_descriptions,
+    get_genes_from_list,
+    analyze_gene_set
+)
+
+from pydantic_ai import RunContext
+
+# Initialize FastMCP server
+mcp = FastMCP("talisman", instructions=TALISMAN_SYSTEM_PROMPT)
+
+def deps() -> TalismanConfig:
+    """Get the Talisman dependencies."""
+    return get_config()
+
+def ctx() -> RunContext[TalismanConfig]:
+    """Get the run context with dependencies."""
+    rc: RunContext[TalismanConfig] = RunContext[TalismanConfig](
+        deps=deps(),
+        model=None, usage=None, prompt=None,
+    )
+    return rc
+
+@mcp.tool()
+async def get_gene_info(gene_id: str) -> str:
+    """
+    Get description for a single gene ID.
+    
+    Args:
+        gene_id: The gene identifier (UniProt ID, gene symbol, etc.)
+        
+    Returns:
+        The gene description in a structured format
+    """
+    return get_gene_description(ctx(), gene_id)
+
+@mcp.tool()
+async def get_multiple_gene_info(gene_ids: str) -> str:
+    """
+    Get descriptions for multiple gene IDs provided as a string.
+    
+    Args:
+        gene_ids: String containing gene identifiers separated by commas, spaces, or newlines
+        
+    Returns:
+        The gene descriptions in a structured format
+    """
+    return get_genes_from_list(ctx(), gene_ids)
+
+@mcp.tool()
+async def analyze_genes(gene_list: str) -> str:
+    """
+    Analyze a set of genes and generate a biological summary of their properties and relationships.
+    
+    Args:
+        gene_list: String containing gene identifiers separated by commas, spaces, or newlines
+        
+    Returns:
+        A structured biological summary of the gene set with Narrative, Functional Terms Table, and Gene Summary Table
+    """
+    return analyze_gene_set(ctx(), gene_list)
+
+if __name__ == "__main__":
+    # Initialize and run the server
+    mcp.run(transport='stdio')