aurelian 0.3.2__py3-none-any.whl

aurelian/dependencies/workdir.py

@@ -0,0 +1,78 @@
+import tempfile
+from abc import ABC
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List
+
+
+@dataclass
+class WorkDir:
+    """
+    Class to handle working directory operations.
+
+    Example:
+
+        >>> wd = WorkDir.create_temporary_workdir()
+        >>> wd.check_file_exists("test.txt")
+        False
+        >>> wd.write_file("test.txt", "Hello, world!")
+        >>> wd.check_file_exists("test.txt")
+        True
+        >>> wd.read_file("test.txt")
+        'Hello, world!'
+    """
+    location: str = field(default_factory=lambda: "/tmp")
+
+    @classmethod
+    def create_temporary_workdir(cls) -> "WorkDir":
+        temp_dir = tempfile.mkdtemp()
+        return cls(location=temp_dir)
+
+    def _ensure_location(self):
+        location = Path(self.location)
+        location.mkdir(parents=True, exist_ok=True)
+
+    def __post_init__(self):
+       self._ensure_location()
+
+
+    def get_file_path(self, file_name: str) -> Path:
+        self._ensure_location()
+        return Path(self.location) / file_name
+
+    def read_file(self, file_path: str) -> str:
+        self._ensure_location()
+        file_path = self.get_file_path(file_path)
+        with open(file_path, "r") as f:
+            return f.read()
+
+    def check_file_exists(self, file_path: str) -> bool:
+        self._ensure_location()
+        return self.get_file_path(file_path).exists()
+
+    def write_file(self, file_path: str, content: str) -> None:
+        self._ensure_location()
+        file_path = self.get_file_path(file_path)
+        with open(file_path, "w") as f:
+            f.write(content)
+
+    def delete_file(self, file_path: str) -> None:
+        self._ensure_location()
+        file_path = self.get_file_path(file_path)
+        file_path.unlink()
+
+    def list_file_names(self) -> List[str]:
+        """
+        List the names of all files in the working directory.
+
+        Note: the working directory is not recursively searched, it is flat
+
+        Returns:
+            list of file names
+        """
+        self._ensure_location()
+        return [f.name for f in Path(self.location).iterdir() if f.is_file()]
+
+@dataclass
+class HasWorkdir(ABC):
+    workdir: WorkDir = field(default_factory=lambda: WorkDir())

aurelian/mcp/amigo_mcp_test.py

@@ -0,0 +1,86 @@
+"""
+Test for AmiGO MCP functionality
+"""
+import os
+import tempfile
+from typing import List, Optional, Dict
+
+# try to import, don't die if import fails
+try:
+    from mcp import Client
+except ImportError:
+    print("mcp package not found. Please install it to run this test.")
+    Client = None
+
+from pydantic import BaseModel
+
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+
+async def test_amigo_mcp():
+    """Test the AmiGO MCP agent."""
+    client = Client("/tmp/amigo-mcp", exec_args=["python", "-m", "aurelian.agents.amigo.amigo_mcp"])
+
+    import time
+    time.sleep(1)  # Give the server time to start
+
+    # Set up a temporary working directory for the test
+    tempdir = os.path.join(tempfile.gettempdir(), "test_amigo")
+    os.makedirs(tempdir, exist_ok=True)
+    os.environ["AURELIAN_WORKDIR"] = tempdir
+
+    # For testing - would normally come from configuration
+    os.environ["AMIGO_TAXON"] = "9606"  # Human
+
+    convo: List[Message] = []
+
+    def add_to_convo(role: str, content: str) -> Message:
+        msg = Message(role=role, content=content)
+        convo.append(msg)
+        return msg
+
+    # Make a query
+    add_to_convo("user", "What tools are available for working with Gene Ontology?")
+
+    message = convo[-1].content
+
+    response = await client.chat(messages=message)
+    print(f"Got response: {response}")
+
+    # Get available tools
+    tool_choices = await client.get_tool_choice(messages=convo)
+    print(f"Available tools: {[t['id'] for t in tool_choices]}")
+
+    # Test gene association lookup
+    find_gene_associations_tool = next((t for t in tool_choices if t["id"] == "find_gene_associations"), None)
+    if find_gene_associations_tool:
+        print(f"Testing find_gene_associations tool...")
+        tool_input = '{"gene_id": "UniProtKB:P04637"}'  # p53
+        try:
+            tool_result = await client.execute_tool(tool_id=find_gene_associations_tool["id"], tool_input=tool_input)
+            print(f"find_gene_associations result length: {len(tool_result)}")
+            print(f"First result: {tool_result[:200]}...")  # Just show first 200 chars
+        except Exception as e:
+            print(f"find_gene_associations failed (expected in test): {e}")
+
+    # Test PMID lookup
+    lookup_pmid_tool = next((t for t in tool_choices if t["id"] == "lookup_pmid"), None)
+    if lookup_pmid_tool:
+        print(f"Testing lookup_pmid tool...")
+        tool_input = '{"pmid": "PMID:19661248"}'
+        try:
+            tool_result = await client.execute_tool(tool_id=lookup_pmid_tool["id"], tool_input=tool_input)
+            print(f"lookup_pmid result length: {len(tool_result)}")
+            print(f"First part of result: {tool_result[:200]}...")
+        except Exception as e:
+            print(f"lookup_pmid failed (expected in test): {e}")
+
+    await client.close()
+
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test_amigo_mcp())

aurelian/mcp/config_generator.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python
+"""
+MCP Configuration Generator
+
+Utility script to generate Model Context Protocol (MCP) server configuration from a simplified input.
+"""
+
+import json
+import os
+import argparse
+from typing import Dict, Optional, Any
+from pathlib import Path
+
+
+class MCPConfigGenerator:
+    """Generator for MCP server configuration."""
+
+    def __init__(self, base_dir: Optional[str] = None):
+        """
+        Initialize the MCP config generator.
+
+        Args:
+            base_dir: Base directory for resolving relative paths (defaults to current working directory)
+        """
+        self.base_dir = base_dir or os.getcwd()
+
+    def generate_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Generate a full MCP server configuration from a simplified config.
+
+        Args:
+            config: Simplified configuration dictionary
+
+        Returns:
+            Complete MCP server configuration
+        """
+        mcp_servers = {}
+
+        for server_name, server_config in config.items():
+            server_type = server_config.get("type", "custom")
+
+            if server_type == "memory":
+                # Memory server configuration
+                memory_path = server_config.get("memory_path", os.path.expanduser("~/.mcp/memory.json"))
+                mcp_servers[server_name] = {
+                    "command": "npx",
+                    "args": ["-y", "@modelcontextprotocol/server-memory"],
+                    "env": {"MEMORY_FILE_PATH": memory_path},
+                }
+            elif server_type in ["linkml", "gocam", "phenopackets", "robot", "amigo", "uniprot", "diagnosis"]:
+                # Aurelian agent MCP server
+                agent_script = f"src/aurelian/agents/{server_type}/{server_type}_mcp.py"
+                workdir = server_config.get("workdir", f"/tmp/{server_type}")
+
+                # Construct environment variables
+                env = {"AURELIAN_WORKDIR": workdir}
+
+                # Add optional environment variables
+                if "email" in server_config:
+                    env["EMAIL"] = server_config["email"]
+                if "doi_urls" in server_config:
+                    env["DOI_FULL_TEXT_URLS"] = server_config["doi_urls"]
+
+                # Add any additional env vars from config
+                if "env" in server_config:
+                    env.update(server_config["env"])
+
+                script_path = str(Path(self.base_dir) / agent_script)
+                mcp_servers[server_name] = {
+                    "command": server_config.get("python_path", "/usr/bin/python"),
+                    "args": [script_path],
+                    "env": env,
+                }
+            elif server_type == "custom":
+                # Custom server configuration (direct passthrough)
+                mcp_servers[server_name] = {
+                    "command": server_config["command"],
+                    "args": server_config["args"],
+                    "env": server_config.get("env", {}),
+                }
+
+        return {"mcpServers": mcp_servers}
+
+    def write_config(self, config: Dict[str, Any], output_path: str) -> None:
+        """
+        Write the generated configuration to a file.
+
+        Args:
+            config: The simplified configuration dictionary
+            output_path: Path to write the generated configuration
+        """
+        full_config = self.generate_config(config)
+
+        with open(output_path, "w") as f:
+            json.dump(full_config, f, indent=2)
+
+        print(f"MCP configuration written to {output_path}")
+
+
+def parse_args():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Generate MCP server configuration")
+    parser.add_argument("--config", "-c", required=True, help="Path to simplified config file")
+    parser.add_argument("--output", "-o", required=True, help="Path to write generated config")
+    parser.add_argument("--base-dir", "-b", help="Base directory for resolving paths")
+    return parser.parse_args()
+
+
+def main():
+    """Main entrypoint."""
+    args = parse_args()
+
+    # Load simplified config
+    with open(args.config) as f:
+        config = json.load(f)
+
+    # Generate and write config
+    generator = MCPConfigGenerator(base_dir=args.base_dir)
+    generator.write_config(config, args.output)
+
+
+if __name__ == "__main__":
+    main()

aurelian/mcp/example_config.json

@@ -0,0 +1,43 @@
+{
+  "memory": {
+    "type": "memory",
+    "memory_path": "~/.mcp/memory.json"
+  },
+  "linkml": {
+    "type": "linkml",
+    "workdir": "/tmp/linkml",
+    "python_path": "/usr/bin/python"
+  },
+  "gocam": {
+    "type": "gocam",
+    "workdir": "/tmp/gocam",
+    "email": "user@example.com",
+    "doi_urls": "https://example.com/doi-resolver",
+    "python_path": "/usr/bin/python"
+  },
+  "phenopackets": {
+    "type": "phenopackets",
+    "workdir": "/tmp/phenopackets",
+    "email": "user@example.com",
+    "python_path": "/usr/bin/python"
+  },
+  "robot": {
+    "type": "robot",
+    "workdir": "/tmp/robot",
+    "python_path": "/usr/bin/python"
+  },
+  "diagnosis": {
+    "type": "diagnosis",
+    "workdir": "/tmp/diagnosis",
+    "python_path": "/usr/bin/python"
+  },
+  "custom_server": {
+    "type": "custom",
+    "command": "/path/to/executable",
+    "args": ["arg1", "arg2"],
+    "env": {
+      "ENV_VAR1": "value1",
+      "ENV_VAR2": "value2"
+    }
+  }
+}

aurelian/mcp/generate_sample_config.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+"""
+Example script to generate a sample MCP configuration file using the config generator.
+"""
+
+import os
+import json
+from pathlib import Path
+from config_generator import MCPConfigGenerator
+
+# Define the base directory for Aurelian
+aurelian_dir = Path(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
+print(f"Aurelian directory: {aurelian_dir}")
+
+# Create a simple configuration
+simple_config = {
+    "memory": {"type": "memory", "memory_path": "~/.mcp/memory.json"},
+    "linkml": {"type": "linkml", "workdir": "/tmp/linkml"},
+    "gocam": {
+        "type": "gocam",
+        "workdir": "/tmp/gocam",
+        "email": "user@example.com",
+        "doi_urls": "https://example.com/doi-resolver",
+    },
+}
+
+# Generate the configuration
+generator = MCPConfigGenerator(base_dir=str(aurelian_dir))
+full_config = generator.generate_config(simple_config)
+
+# Write to a file
+output_path = aurelian_dir / "mcp-config.json"
+with open(output_path, "w") as f:
+    json.dump(full_config, f, indent=2)
+
+print(f"Generated MCP configuration at: {output_path}")
+print("Use with: mcp start --config mcp-config.json")

aurelian/mcp/gocam_mcp_test.py

@@ -0,0 +1,126 @@
+"""
+Test for GOCAM MCP functionality
+"""
+import os
+import tempfile
+from typing import List, Optional, Dict
+
+# try to import, don't die if import fails
+try:
+    from mcp import Client
+except ImportError:
+    print("mcp package not found. Please install it to run this test.")
+    Client = None
+
+from pydantic import BaseModel
+
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+
+async def test_gocam_mcp():
+    """Test the GOCAM MCP agent."""
+    client = Client("/tmp/gocam-mcp", exec_args=["python", "-m", "aurelian.agents.gocam.gocam_mcp"])
+
+    import time
+    time.sleep(1)  # Give the server time to start
+
+    # Set up a temporary working directory for the test
+    tempdir = os.path.join(tempfile.gettempdir(), "test_gocam")
+    os.makedirs(tempdir, exist_ok=True)
+    os.environ["AURELIAN_WORKDIR"] = tempdir
+
+    # For testing without a real database - would normally come from configuration
+    os.environ["GOCAM_DB_PATH"] = "mongodb://localhost:27017/test_gocams"
+    os.environ["GOCAM_DB_NAME"] = "test_gocams"
+    os.environ["GOCAM_COLLECTION_NAME"] = "test_main"
+
+    convo: List[Message] = []
+
+    def add_to_convo(role: str, content: str) -> Message:
+        msg = Message(role=role, content=content)
+        convo.append(msg)
+        return msg
+
+    # Make a query
+    add_to_convo("user", "What tools are available for working with GO-CAMs?")
+
+    message = convo[-1].content
+
+    response = await client.chat(messages=message)
+    print(f"Got response: {response}")
+
+    # Get available tools
+    tool_choices = await client.get_tool_choice(messages=convo)
+    print(f"Available tools: {[t['id'] for t in tool_choices]}")
+
+    # Test the list_files tool
+    list_files_tool = next((t for t in tool_choices if t["id"] == "list_files"), None)
+    if list_files_tool:
+        print(f"Testing list_files tool...")
+        tool_input_schema = await client.get_tool_input_schema(tool_id=list_files_tool["id"])
+        tool_result = await client.execute_tool(tool_id=list_files_tool["id"], tool_input='{}')
+        print(f"list_files result: {tool_result}")
+
+    # Create a test file
+    write_file_tool = next((t for t in tool_choices if t["id"] == "write_to_file"), None)
+    if write_file_tool:
+        print(f"Testing write_to_file tool...")
+        tool_input = '{"file_name": "gocam_test.txt", "data": "This is a test file for GOCAM MCP"}'
+        tool_result = await client.execute_tool(tool_id=write_file_tool["id"], tool_input=tool_input)
+        print(f"write_to_file result: {tool_result}")
+
+    # Check if the file was created
+    if list_files_tool:
+        tool_result = await client.execute_tool(tool_id=list_files_tool["id"], tool_input='{}')
+        print(f"list_files after writing: {tool_result}")
+
+    # Read the file
+    inspect_file_tool = next((t for t in tool_choices if t["id"] == "inspect_file"), None)
+    if inspect_file_tool:
+        print(f"Testing inspect_file tool...")
+        tool_input = '{"data_file": "gocam_test.txt"}'
+        tool_result = await client.execute_tool(tool_id=inspect_file_tool["id"], tool_input=tool_input)
+        print(f"inspect_file result: {tool_result}")
+
+    # Try search function
+    search_tool = next((t for t in tool_choices if t["id"] == "search_gocams"), None)
+    if search_tool:
+        print(f"Testing search_gocams tool...")
+        tool_input = '{"query": "apoptosis"}'
+        try:
+            tool_result = await client.execute_tool(tool_id=search_tool["id"], tool_input=tool_input)
+            print(f"search_gocams result: {tool_result[:200]}...")  # Just show first 200 chars
+        except Exception as e:
+            print(f"search_gocams failed (expected in test): {e}")
+    
+    # Test fetch_document
+    fetch_doc_tool = next((t for t in tool_choices if t["id"] == "fetch_document"), None)
+    if fetch_doc_tool:
+        print(f"Testing fetch_document tool...")
+        tool_input = '{"name": "Signaling receptor activity annotation guidelines"}'
+        try:
+            tool_result = await client.execute_tool(tool_id=fetch_doc_tool["id"], tool_input=tool_input)
+            print(f"fetch_document result: {tool_result[:200]}...")  # Just show first 200 chars
+        except Exception as e:
+            print(f"fetch_document failed (expected in test without available docs): {e}")
+    
+    # Test validate_gocam_model
+    validate_tool = next((t for t in tool_choices if t["id"] == "validate_gocam_model"), None)
+    if validate_tool:
+        print(f"Testing validate_gocam_model tool...")
+        valid_model = '{"model_data": "{\\"id\\": \\"gomodel:test123\\", \\"title\\": \\"Test Model\\"}", "format": "json"}'
+        try:
+            tool_result = await client.execute_tool(tool_id=validate_tool["id"], tool_input=valid_model)
+            print(f"validate_gocam_model result: {tool_result[:200]}...")
+        except Exception as e:
+            print(f"validate_gocam_model failed: {e}")
+
+    await client.close()
+
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test_gocam_mcp())

aurelian/mcp/linkml_mcp_tools.py

@@ -0,0 +1,190 @@
+"""
+MCP tools for creating LinkML schemas and example datasets
+"""
+from linkml.generators import JsonSchemaGenerator
+from mcp.server.fastmcp import FastMCP
+
+from aurelian.agents.linkml.linkml_agent import LinkMLDependencies
+
+# Initialize FastMCP server
+mcp = FastMCP("linkml")
+
+import logfire
+from linkml_runtime.loaders import yaml_loader
+from linkml_runtime.linkml_model import SchemaDefinition
+from linkml.validator import validate
+from pydantic_ai import RunContext, ModelRetry
+
+from aurelian.dependencies.workdir import WorkDir
+
+def deps() -> LinkMLDependencies:
+    deps = LinkMLDependencies()
+    deps.workdir = WorkDir("/tmp/linkml")
+    return deps
+
+def ctx() -> RunContext[LinkMLDependencies]:
+    rc: RunContext[LinkMLDependencies] = RunContext[LinkMLDependencies](deps=deps())
+    return rc
+
+
+@mcp.tool()
+async def validate_schema(schema: str, save_to_file: str="schema.yaml") -> str:
+    """
+    Validate a LinkML schema.
+
+    Args:
+        ctx: context
+        schema: schema (as yaml) to validate. Do not truncate, always pass the whole schema.
+        save_to_file: optional file name to save the schema to. Defaults to schema.yaml
+
+    Returns:
+
+    """
+    print(f"Validating schema: {schema}")
+    try:
+        schema = yaml_loader.loads(schema, target_class=SchemaDefinition)
+        gen = JsonSchemaGenerator(schema)
+        gen.serialize()
+        if save_to_file and schema:
+            deps().workdir.write_file(save_to_file, schema)
+    except Exception as e:
+        raise ModelRetry(f"Schema does not validate: {e}")
+    return "VALIDATES"
+
+
+@mcp.tool()
+async def inspect_file(data_file: str) -> str:
+    """
+    Inspect a file in the working directory.
+
+    Args:
+        ctx:
+        data_file: name of file
+
+    Returns:
+
+    """
+    print(f"Inspecting file: {data_file}")
+    return deps().workdir.read_file(data_file)
+
+
+@mcp.tool()
+async def list_files() -> str:
+    """
+    List files in the working directory.
+
+    Args:
+        ctx:
+
+    Returns:
+
+    """
+    return "\n".join(deps().workdir.list_file_names())
+
+@mcp.tool()
+async def write_to_file(data: str, file_name: str) -> str:
+    """
+    Write data to a file in the working directory.
+
+    Args:
+        ctx:
+        data:
+        file_name:
+
+    Returns:
+
+    """
+    print(f"Writing data to file: {file_name}")
+    deps().workdir.write_file(file_name, data)
+    return f"Data written to {file_name}"
+
+@mcp.tool()
+async def validate_data(schema: str, data_file: str) -> str:
+    """
+    Validate data file against a schema.
+
+    This assumes the data file is present in the working directory.
+    You can write data to the working directory using the `write_to_file` tool.
+
+    Args:
+        ctx:
+        schema: the schema (as a YAML string)
+        data_file: the name of the data file in the working directory
+
+    Returns:
+
+    """
+    logfire.log(f"Validating data file: {data_file} using schema: {schema}")
+    print(f"Validating data file: {data_file} using schema: {schema}")
+    try:
+        schema = yaml_loader.loads(schema, target_class=SchemaDefinition)
+    except Exception as e:
+        return f"Schema does not validate: {e}"
+    try:
+        instances = deps().parse_objects_from_file(data_file)
+        for instance in instances:
+            print(f"Validating {instance}")
+            rpt = validate(instance, schema)
+            print(f"Validation report: {rpt}")
+            if rpt.results:
+                return f"Data does not validate:\n{rpt.results}"
+        return f"{len(instances)} instances all validate successfully"
+    except Exception as e:
+        return f"Data does not validate: {e}"
+
+
+@mcp.tool()
+async def search_web(query: str) -> str:
+    """
+    Search the web using a text query.
+
+    Note, this will not retrieve the full content, for that you
+    should use `retrieve_web_page`.
+
+    Args:
+        query: Text query
+
+    Returns: matching web pages plus summaries
+    """
+    print(f"Web Search: {query}")
+    return web_search(query)
+
+@mcp.tool()
+async def retrieve_web_page(url: str) -> str:
+    """
+    Fetch the contents of a web page.
+
+    Args:
+        url: URL of the web page
+
+    Returns:
+        The contents of the web page.
+    """
+    print(f"Fetch URL: {url}")
+    import aurelian.utils.search_utils as su
+    return su.retrieve_web_page(url)
+
+
+@mcp.tool()
+async def download_web_page(url: str, local_file_name: str) -> str:
+    """
+    Download contents of a web page.
+
+    Args:
+        ctx:
+        url: URL of the web page
+        local_file_name: Name of the local file to save the
+
+    Returns:
+        str: message
+    """
+    print(f"Fetch URL: {url}")
+    import aurelian.utils.search_utils as su
+    data = su.retrieve_web_page(url)
+    deps().workdir.write_file(local_file_name, data)
+    return f"Data written to {local_file_name}"
+
+
+if __name__ == "__main__":
+    # Initialize and run the server
+    mcp.run(transport='stdio')