Initial commit

Author: justaddcoffee

.gitignore

@@ -0,0 +1,48 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Editor settings
+.idea/
+.vscode/
+*.swp
+*.swo
+.claude

README.md

@@ -0,0 +1,52 @@
+# ols-mcp
+
+MCP for retrieving things from the Ontology Lookup  Service
+
+## Installation
+
+You can install the package from source:
+
+```bash
+pip install -e .
+```
+
+Or using uv:
+
+```bash
+uv pip install -e .
+```
+
+## Usage
+
+You can use the CLI:
+
+```bash
+ols_mcp 
+```
+
+Or import in your Python code:
+
+```python
+from ols_mcp.main import create_mcp
+
+mcp = create_mcp()
+mcp.run()
+```
+
+## Development
+
+### Local Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/justaddcoffee/ols-mcp.git
+cd ols-mcp
+
+# Install development dependencies
+uv pip install -e ".[dev]"
+```
+
+
+## License
+
+BSD-3-Clause

pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ols-mcp"
+version = "0.1.0"
+description = "MCP for retrieving things from the Ontology Lookup  Service"
+readme = "README.md"
+authors = [
+    {name = "Justin Reese", email = "justinreese@lbl.gov"},
+]
+requires-python = ">=3.11"
+dependencies = [
+    "fastmcp>=2.7.1",
+    "requests>=2.32.4",
+]
+
+[dependency-groups]
+dev = [
+  "pytest",
+  "black",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/justaddcoffee/ols-mcp"
+"Bug Tracker" = "https://github.com/justaddcoffee/ols-mcp/issues"
+
+[project.scripts]
+ols-mcp = "ols_mcp.main:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ols_mcp"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

src/ols_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""ols-mcp package for querying database_name API."""
+
+__version__ = "0.1.0"

src/ols_mcp/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    main()

src/ols_mcp/api.py

@@ -0,0 +1,152 @@
+################################################################################
+# ols_mcp/api.py
+# This module contains wrapper functions that interact with the OLS API endpoints
+################################################################################
+import json
+from typing import Any, Dict, List, Optional, Union
+import requests
+
+
+def search_ontologies(
+    query: str,
+    ontologies: Optional[List[str]] = None,
+    max_results: int = 20,
+    exact: bool = False,
+    verbose: bool = False,
+) -> List[Dict[str, Any]]:
+    """
+    Search across all ontologies in the OLS.
+
+    Args:
+        query: The search term
+        ontologies: List of specific ontology IDs to search within (optional)
+        max_results: Maximum number of results to return
+        exact: Whether to perform exact matching
+        verbose: If True, print progress information during retrieval
+
+    Returns:
+        A list of dictionaries, where each dictionary represents a search result.
+    """
+    base_url = "https://www.ebi.ac.uk/ols/api/search"
+    
+    params = {
+        "q": query,
+        "rows": max_results,
+        "exact": exact
+    }
+    
+    if ontologies:
+        params["ontology"] = ",".join(ontologies)
+    
+    if verbose:
+        print(f"Searching OLS for: {query}")
+    
+    response = requests.get(base_url, params=params)
+    response.raise_for_status()
+    data = response.json()
+    
+    # Extract the docs from the response
+    results = data.get("response", {}).get("docs", [])
+    
+    if verbose:
+        print(f"Found {len(results)} results")
+    
+    return results
+
+
+def get_ontology_details(ontology_id: str, verbose: bool = False) -> Dict[str, Any]:
+    """
+    Get details about a specific ontology.
+
+    Args:
+        ontology_id: The ID of the ontology (e.g., 'go', 'uberon')
+        verbose: If True, print progress information
+
+    Returns:
+        A dictionary containing ontology details.
+    """
+    base_url = f"https://www.ebi.ac.uk/ols/api/ontologies/{ontology_id}"
+    
+    if verbose:
+        print(f"Fetching details for ontology: {ontology_id}")
+    
+    response = requests.get(base_url)
+    response.raise_for_status()
+    data = response.json()
+    
+    if verbose:
+        print(f"Retrieved details for {ontology_id}")
+    
+    return data
+
+
+def get_ontology_terms(
+    ontology_id: str,
+    max_results: int = 20,
+    page_size: int = 20,
+    iri: Optional[str] = None,
+    short_form: Optional[str] = None,
+    obo_id: Optional[str] = None,
+    verbose: bool = False,
+) -> List[Dict[str, Any]]:
+    """
+    Get classes/terms from a specific ontology.
+
+    Args:
+        ontology_id: The ID of the ontology (e.g., 'go', 'uberon')
+        max_results: Maximum number of results to return
+        page_size: Number of results per page
+        iri: Filter by specific IRI
+        short_form: Filter by short form
+        obo_id: Filter by OBO ID
+        verbose: If True, print progress information
+
+    Returns:
+        A list of dictionaries, where each dictionary represents a term.
+    """
+    base_url = f"https://www.ebi.ac.uk/ols/api/ontologies/{ontology_id}/terms"
+    
+    params = {"size": min(page_size, max_results)}
+    
+    if iri:
+        params["iri"] = iri
+    if short_form:
+        params["short_form"] = short_form
+    if obo_id:
+        params["obo_id"] = obo_id
+    
+    all_terms = []
+    page = 0
+    
+    if verbose:
+        print(f"Fetching terms from ontology: {ontology_id}")
+    
+    while len(all_terms) < max_results:
+        params["page"] = page
+        
+        response = requests.get(base_url, params=params)
+        response.raise_for_status()
+        data = response.json()
+        
+        terms = data.get("_embedded", {}).get("terms", [])
+        if not terms:
+            break
+            
+        all_terms.extend(terms)
+        
+        if verbose:
+            print(f"Fetched page {page + 1}, total terms so far: {len(all_terms)}")
+        
+        # Check if we have more pages
+        if not data.get("page", {}).get("number", 0) < data.get("page", {}).get("totalPages", 0) - 1:
+            break
+            
+        page += 1
+    
+    # Truncate to max_results
+    result = all_terms[:max_results]
+    
+    if verbose:
+        print(f"Retrieved {len(result)} terms from {ontology_id}")
+    
+    return result

src/ols_mcp/main.py

@@ -0,0 +1,29 @@
+################################################################################
+# ols_mcp/main.py
+# This module sets up the FastMCP CLI interface
+################################################################################
+
+from fastmcp import FastMCP
+from ols_mcp.tools import (
+    search_all_ontologies,
+    get_ontology_info,
+    get_terms_from_ontology
+)
+
+
+# Create the FastMCP instance at module level
+mcp = FastMCP("ols_mcp")
+
+# Register all tools
+mcp.tool(search_all_ontologies)
+mcp.tool(get_ontology_info)
+mcp.tool(get_terms_from_ontology)
+
+
+def main():
+    """Main entry point for the application."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()