lifesciences-research: Command for Claude Code

User Input

$ARGUMENTS

You MUST consider the user input before proceeding. Expected format:

• <api-name> - e.g., "uniprot", "chembl", "opentargets"

If no argument provided, ask the user for the API name.

Goal

Create the complete scaffolding for a new FastMCP MCP server following the Life Sciences project architecture defined in ADR-001. This skill implements Constitution Principle VI (Platform Skill Delegation) to ensure consistent project structure.

Generated Structure

src/lifesciences_mcp/
├── clients/
│   └── <api>.py              # Client stub (ADR-006)
├── servers/
│   └── <api>.py              # FastMCP server with tool stubs
└── (existing files preserved)

tests/
├── unit/
│   └── test_<api>_models.py  # Unit test stubs
└── integration/
    └── test_<api>_api.py     # Integration test stubs

Execution Steps

1. Validate Input

• Extract API name from arguments (lowercase, alphanumeric with underscores)
• Validate against existing servers in src/lifesciences_mcp/servers/
• If server already exists, abort with message

2. Read Existing Patterns

Read the following files to understand established patterns:

• src/lifesciences_mcp/servers/hgnc.py - Server pattern
• src/lifesciences_mcp/clients/hgnc.py - Client pattern
• src/lifesciences_mcp/models/envelopes.py - Envelope models
• tests/integration/test_hgnc_api.py - Test pattern

3. Generate Server File

Create src/lifesciences_mcp/servers/<api>.py with:

"""<API_NAME> MCP Server - <Brief description>.

This server provides tools for <API purpose>:
- search_<entities>: Fuzzy search returning ranked candidates
- get_<entity>: Strict lookup by <ID_TYPE> CURIE

Usage:
    uv run fastmcp run src/lifesciences_mcp/servers/<api>.py
"""

from fastmcp import FastMCP

from lifesciences_mcp.clients import <API>Client
from lifesciences_mcp.models import (
    ErrorEnvelope,
    PaginationEnvelope,
)

# Initialize the MCP server
mcp = FastMCP("<API_NAME> Server")

# Shared client instance (connection pooling)
# Lifecycle managed by module-level singleton pattern
_client: <API>Client | None = None


async def get_client() -> <API>Client:
    """Get or create the shared <API> client."""
    global _client
    if _client is None:
        _client = <API>Client()
    return _client


@mcp.tool
async def search_<entities>(
    query: str,
    slim: bool = False,
    cursor: str | None = None,
    page_size: int = 50,
) -> PaginationEnvelope | ErrorEnvelope:
    """Fuzzy search for <entities>.

    Args:
        query: Search term.
        slim: If true, return minimal fields (~20 tokens per entity).
        cursor: Opaque cursor for pagination.
        page_size: Number of results per page (1-100, default 50).

    Returns:
        PaginationEnvelope with items, or ErrorEnvelope on failure.
    """
    client = await get_client()
    return await client.search_<entities>(
        query=query,
        slim=slim,
        cursor=cursor,
        page_size=page_size,
    )


@mcp.tool
async def get_<entity>(<id_param>: str) -> dict | ErrorEnvelope:
    """Get complete <entity> record by <ID_TYPE> CURIE.

    Args:
        <id_param>: <ID_TYPE> CURIE in format '<PREFIX>:NNNNN'.

    Returns:
        <Entity> record, or ErrorEnvelope on failure.
    """
    client = await get_client()
    return await client.get_<entity>(<id_param>=<id_param>)


if __name__ == "__main__":
    mcp.run()