smartapi-mcp 0.2.0__tar.gz → 0.3.0__tar.gz

{smartapi_mcp-0.2.0 → smartapi_mcp-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smartapi-mcp
-Version: 0.2.0
+Version: 0.3.0
 Summary: Create MCP servers for one or multiple APIs registered in SmartAPI registry
 Author-email: BioThings Team <help@biothings.io>
 Maintainer-email: BioThings Team <help@biothings.io>
@@ -24,7 +24,8 @@ Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: awslabs_openapi_mcp_server>=0.2.12
+Requires-Dist: awslabs_openapi_mcp_server<1,>=0.2.12
+Requires-Dist: fastmcp<3,>=2.14
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
@@ -60,7 +61,9 @@ Built on top of the [AWS Labs OpenAPI MCP Server](https://github.com/awslabs/ope
 
 - Python 3.10 or higher
 - Network access to SmartAPI registry (https://smart-api.info)
-- Dependencies: `awslabs_openapi_mcp_server>=0.2.12`
+- Dependencies: `awslabs_openapi_mcp_server>=0.2.12,<1` and `fastmcp>=2.14,<3`
+  (awslabs 1.x / fastmcp 3.x are not yet supported — see the dependency notes in
+  `pyproject.toml`)
 
 ## Features
 
@@ -70,9 +73,10 @@ Built on top of the [AWS Labs OpenAPI MCP Server](https://github.com/awslabs/ope
 - 📖 **OpenAPI Validation**: Automatic OpenAPI specification parsing and validation
 - 🛠️ **CLI Interface**: Easy-to-use command-line interface with multiple configuration options
 - 🧬 **Bioinformatics Focus**: Pre-configured API sets for bioinformatics and life sciences
+- 🧩 **Scales to large API sets**: Large BioThings sets (e.g. `biothings_all`, 200+ operations) automatically collapse to ~5 generic tools, avoiding client context overflow without relying on client-side tool deferral
 - 🎯 **Flexible Configuration**: Support for environment variables, arguments, and configuration files
 - 🚀 **Multiple Transport Modes**: Support for both stdio and HTTP transport protocols
-- 🧪 **Comprehensive Testing**: Full test suite with 99% code coverage
+- 🧪 **Comprehensive Testing**: Full test suite with high code coverage
 
 ## Installation
 
@@ -197,6 +201,51 @@ For other MCP clients that support external MCP servers, you can typically confi
 }
 ```
 
+#### Large API Sets (`biothings_all`) — the BioThings facade
+
+All BioThings APIs share the same handful of operations (`/query`,
+`/{type}/{id}`, batch lookups, `/metadata/fields`). Emitting one MCP tool per
+(API × operation) for a large set like `biothings_all` would create 200+
+near-duplicate tools and overflow the client's context window.
+
+To avoid this, for large BioThings sets the server exposes a small **fixed set
+of ~5 generic tools** where the target API is a *parameter*:
+
+- `list_biothings_apis` — discover/search the available APIs (returns data)
+- `biothings_query` — search any API (`/query`)
+- `biothings_get` / `biothings_getbatch` — annotation lookup by id(s)
+- `biothings_fields` — list queryable fields for an API
+
+Because the tool list is small and static, this works on **every** MCP client
+(no dependency on dynamic `tools/list_changed` updates).
+
+For a **mixed** set (BioThings + other API types), the server is *hybrid*: the
+BioThings APIs are served through the facade, while any non-BioThings APIs are
+added as faithful per-API tools in the same server — so no APIs are lost.
+
+```json
+{
+  "mcpServers": {
+    "biothings-all": {
+      "command": "uvx",
+      "args": ["smartapi-mcp", "--api_set", "biothings_all"]
+    }
+  }
+}
+```
+
+Control the strategy with `--facade {auto,on,off}` (default `auto`, which
+engages the facade once the BioThings APIs in the set reach
+`--facade-threshold`, default 10) or the `SMARTAPI_FACADE` environment variable.
+Use `--facade off` to force faithful per-API tools regardless of set size.
+
+A few BioThings APIs expose extra, non-standard endpoints (e.g. SemmedDB's
+`/query/ngd`) that the generic facade tools can't reach. These are rare, so by
+default they're ignored. Pass `--facade-strict` (or `FACADE_STRICT=1`) to
+inspect each BioThings spec at startup and serve any API that has extra
+endpoints with faithful per-API tools instead — at the cost of slower startup
+(it downloads the specs upfront).
+
 #### Development/Testing Setup
 
 ```json
@@ -482,6 +531,11 @@ export SMARTAPI_Q="tags.name=biothings"
 export SMARTAPI_API_SET="biothings_core"
 export SMARTAPI_EXCLUDE_IDS="exclude_id1,exclude_id2"
 
+# BioThings facade strategy (see "Large API Sets" above)
+export SMARTAPI_FACADE="auto"     # auto | on | off
+export FACADE_THRESHOLD="10"      # min BioThings APIs before 'auto' uses the facade
+export FACADE_STRICT="false"      # inspect specs; serve APIs with extra endpoints per-API
+
 # Server configuration
 export SERVER_NAME="My SmartAPI MCP Server"
 export TRANSPORT="http"

{smartapi_mcp-0.2.0 → smartapi_mcp-0.3.0}/README.md

@@ -17,7 +17,9 @@ Built on top of the [AWS Labs OpenAPI MCP Server](https://github.com/awslabs/ope
 
 - Python 3.10 or higher
 - Network access to SmartAPI registry (https://smart-api.info)
-- Dependencies: `awslabs_openapi_mcp_server>=0.2.12`
+- Dependencies: `awslabs_openapi_mcp_server>=0.2.12,<1` and `fastmcp>=2.14,<3`
+  (awslabs 1.x / fastmcp 3.x are not yet supported — see the dependency notes in
+  `pyproject.toml`)
 
 ## Features
 
@@ -27,9 +29,10 @@ Built on top of the [AWS Labs OpenAPI MCP Server](https://github.com/awslabs/ope
 - 📖 **OpenAPI Validation**: Automatic OpenAPI specification parsing and validation
 - 🛠️ **CLI Interface**: Easy-to-use command-line interface with multiple configuration options
 - 🧬 **Bioinformatics Focus**: Pre-configured API sets for bioinformatics and life sciences
+- 🧩 **Scales to large API sets**: Large BioThings sets (e.g. `biothings_all`, 200+ operations) automatically collapse to ~5 generic tools, avoiding client context overflow without relying on client-side tool deferral
 - 🎯 **Flexible Configuration**: Support for environment variables, arguments, and configuration files
 - 🚀 **Multiple Transport Modes**: Support for both stdio and HTTP transport protocols
-- 🧪 **Comprehensive Testing**: Full test suite with 99% code coverage
+- 🧪 **Comprehensive Testing**: Full test suite with high code coverage
 
 ## Installation
 
@@ -154,6 +157,51 @@ For other MCP clients that support external MCP servers, you can typically confi
 }
 ```
 
+#### Large API Sets (`biothings_all`) — the BioThings facade
+
+All BioThings APIs share the same handful of operations (`/query`,
+`/{type}/{id}`, batch lookups, `/metadata/fields`). Emitting one MCP tool per
+(API × operation) for a large set like `biothings_all` would create 200+
+near-duplicate tools and overflow the client's context window.
+
+To avoid this, for large BioThings sets the server exposes a small **fixed set
+of ~5 generic tools** where the target API is a *parameter*:
+
+- `list_biothings_apis` — discover/search the available APIs (returns data)
+- `biothings_query` — search any API (`/query`)
+- `biothings_get` / `biothings_getbatch` — annotation lookup by id(s)
+- `biothings_fields` — list queryable fields for an API
+
+Because the tool list is small and static, this works on **every** MCP client
+(no dependency on dynamic `tools/list_changed` updates).
+
+For a **mixed** set (BioThings + other API types), the server is *hybrid*: the
+BioThings APIs are served through the facade, while any non-BioThings APIs are
+added as faithful per-API tools in the same server — so no APIs are lost.
+
+```json
+{
+  "mcpServers": {
+    "biothings-all": {
+      "command": "uvx",
+      "args": ["smartapi-mcp", "--api_set", "biothings_all"]
+    }
+  }
+}
+```
+
+Control the strategy with `--facade {auto,on,off}` (default `auto`, which
+engages the facade once the BioThings APIs in the set reach
+`--facade-threshold`, default 10) or the `SMARTAPI_FACADE` environment variable.
+Use `--facade off` to force faithful per-API tools regardless of set size.
+
+A few BioThings APIs expose extra, non-standard endpoints (e.g. SemmedDB's
+`/query/ngd`) that the generic facade tools can't reach. These are rare, so by
+default they're ignored. Pass `--facade-strict` (or `FACADE_STRICT=1`) to
+inspect each BioThings spec at startup and serve any API that has extra
+endpoints with faithful per-API tools instead — at the cost of slower startup
+(it downloads the specs upfront).
+
 #### Development/Testing Setup
 
 ```json
@@ -439,6 +487,11 @@ export SMARTAPI_Q="tags.name=biothings"
 export SMARTAPI_API_SET="biothings_core"
 export SMARTAPI_EXCLUDE_IDS="exclude_id1,exclude_id2"
 
+# BioThings facade strategy (see "Large API Sets" above)
+export SMARTAPI_FACADE="auto"     # auto | on | off
+export FACADE_THRESHOLD="10"      # min BioThings APIs before 'auto' uses the facade
+export FACADE_STRICT="false"      # inspect specs; serve APIs with extra endpoints per-API
+
 # Server configuration
 export SERVER_NAME="My SmartAPI MCP Server"
 export TRANSPORT="http"

{smartapi_mcp-0.2.0 → smartapi_mcp-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "smartapi-mcp"
-version = "0.2.0"
+version = "0.3.0"
 description = "Create MCP servers for one or multiple APIs registered in SmartAPI registry"
 readme = "README.md"
 license = "Apache-2.0"
@@ -31,7 +31,12 @@ classifiers = [
 keywords = ["mcp", "smartapi", "api", "server", "bioinformatics"]
 requires-python = ">=3.10"
 dependencies = [
-    "awslabs_openapi_mcp_server>=0.2.12",
+    # awslabs 1.x requires fastmcp 3.x, which removed FastMCP.get_tools() and
+    # rejects *args tool functions -- incompatible with this package for now.
+    # fastmcp is also pinned <3 directly because awslabs 0.2.x allows fastmcp>=2.14
+    # with no upper bound and would otherwise resolve to the breaking 3.x.
+    "awslabs_openapi_mcp_server>=0.2.12,<1",
+    "fastmcp>=2.14,<3",
 ]
 
 [project.optional-dependencies]

{smartapi_mcp-0.2.0 → smartapi_mcp-0.3.0}/smartapi_mcp/__init__.py

@@ -4,28 +4,39 @@ SmartAPI MCP Server Package
 Create MCP servers for one or multiple APIs registered in SmartAPI registry.
 """
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __author__ = "BioThings Team"
 __email__ = "help@biothings.io"
 
 # Optional imports for when dependencies are available
 try:
-    from .server import get_mcp_server, get_merged_mcp_server, merge_mcp_servers
+    from .biothings import build_biothings_facade, build_registry
+    from .server import (
+        build_server_for_set,
+        get_mcp_server,
+        get_merged_mcp_server,
+        merge_mcp_servers,
+    )
     from .smartapi import (
         PREDEFINED_API_SETS,
         get_base_server_url,
         get_predefined_api_set,
         get_smartapi_ids,
+        get_smartapi_registry,
         load_api_spec,
     )
 
     __all__ = [
         "PREDEFINED_API_SETS",
+        "build_biothings_facade",
+        "build_registry",
+        "build_server_for_set",
         "get_base_server_url",
         "get_mcp_server",
         "get_merged_mcp_server",
         "get_predefined_api_set",
         "get_smartapi_ids",
+        "get_smartapi_registry",
         "load_api_spec",
         "merge_mcp_servers",
     ]

smartapi_mcp-0.3.0/smartapi_mcp/biothings.py

@@ -0,0 +1,381 @@
+"""
+BioThings generic-facade MCP server.
+
+BioThings APIs all expose the same handful of operations (``/query``,
+``/{type}/{id}``, batch ``POST /{type}``, ``/metadata/fields``). Rather than
+emitting one MCP tool per (API x operation) -- which explodes to 200+ near
+duplicate tools for ``biothings_all`` and overflows client context -- this
+module exposes a small, fixed set of *generic* tools where the target API is a
+parameter. The tool count stays constant (~5) no matter how many APIs are in
+the set, so the server works on every MCP client without depending on runtime
+``tools/list_changed`` notifications.
+"""
+
+import asyncio
+import re
+from dataclasses import dataclass, field
+
+import httpx
+from awslabs.openapi_mcp_server import logger
+from fastmcp import FastMCP
+from fastmcp.tools import Tool
+
+from .smartapi import (
+    HTTP_TIMEOUT,
+    get_base_server_url,
+    get_smartapi_registry,
+    load_api_spec,
+)
+
+# Matches a BioThings annotation path like ``/gene/{geneid}`` and captures the
+# entity (biothing) type segment.
+_BIOTHING_PATH_RE = re.compile(r"^/(?P<type>[^/{}]+)/\{[^/]+\}$")
+
+# Truncate API descriptions in discovery output to keep the payload small.
+_MAX_DESC_LEN = 200
+
+# HTTP methods recognized when enumerating spec operations.
+_HTTP_METHODS = {"get", "post", "put", "delete", "patch", "head", "options"}
+
+
+@dataclass
+class BioThingsAPIEntry:
+    """A single BioThings API in the facade registry."""
+
+    name: str  # short slug used as the ``api`` argument value, e.g. "mygene"
+    smartapi_id: str
+    title: str = ""
+    description: str = ""
+    tags: list[str] = field(default_factory=list)
+    # Resolved lazily on first use (one spec download per API):
+    base_url: str | None = None
+    biothing_type: str | None = None
+
+
+def _slugify_title(title: str) -> str:
+    """Turn an API title into a short slug, e.g. 'MyGene.info API' -> 'mygene'."""
+    slug = title.lower()
+    slug = re.sub(r"\.info\b", "", slug)
+    slug = re.sub(r"\bapi\b", "", slug)
+    slug = re.sub(r"[^a-z0-9]+", "_", slug).strip("_")
+    return slug or "api"
+
+
+def build_registry_from_entries(entries: list[dict]) -> dict[str, BioThingsAPIEntry]:
+    """Build a slug -> entry registry from raw SmartAPI registry records.
+
+    Slugs are derived from API titles and de-duplicated with numeric suffixes.
+    """
+    registry: dict[str, BioThingsAPIEntry] = {}
+    for record in entries:
+        smartapi_id = record.get("_id", "")
+        if not smartapi_id:
+            continue
+        title = record.get("title", "") or smartapi_id
+        base_slug = _slugify_title(title)
+        slug = base_slug
+        suffix = 2
+        while slug in registry:
+            slug = f"{base_slug}_{suffix}"
+            suffix += 1
+        registry[slug] = BioThingsAPIEntry(
+            name=slug,
+            smartapi_id=smartapi_id,
+            title=title,
+            description=record.get("description", "") or "",
+            tags=list(record.get("tags", []) or []),
+        )
+    return registry
+
+
+async def build_registry(
+    smartapi_ids: list[str] | None = None, *, q: str | None = None
+) -> dict[str, BioThingsAPIEntry]:
+    """Build the facade registry from a set of IDs (or a registry query)."""
+    entries = await get_smartapi_registry(q=q, ids=smartapi_ids)
+    return build_registry_from_entries(entries)
+
+
+def is_biothings_registry(registry: dict[str, BioThingsAPIEntry]) -> bool:
+    """True only if every API in the registry is tagged ``biothings``."""
+    if not registry:
+        return False
+    return all("biothings" in entry.tags for entry in registry.values())
+
+
+def _resolve_endpoints(entry: BioThingsAPIEntry) -> None:
+    """Lazily resolve and cache ``base_url`` and ``biothing_type`` from the spec."""
+    if entry.base_url is not None and entry.biothing_type is not None:
+        return
+    spec = load_api_spec(entry.smartapi_id)
+    if entry.base_url is None:
+        entry.base_url = get_base_server_url(spec).rstrip("/")
+    if entry.biothing_type is None:
+        for path in spec.get("paths", {}):
+            match = _BIOTHING_PATH_RE.match(path)
+            if match:
+                entry.biothing_type = match.group("type")
+                break
+
+
+def _normalize_path(path: str) -> str:
+    """Replace any ``{param}`` segment with ``{}`` so paths compare structurally."""
+    return re.sub(r"\{[^/}]+\}", "{}", path)
+
+
+def _spec_operations(spec: dict) -> set[tuple[str, str]]:
+    """Return the set of ``(METHOD, normalized_path)`` operations in a spec."""
+    ops: set[tuple[str, str]] = set()
+    for path, item in spec.get("paths", {}).items():
+        if not isinstance(item, dict):
+            continue
+        norm = _normalize_path(path)
+        for method in item:
+            if method.lower() in _HTTP_METHODS:
+                ops.add((method.upper(), norm))
+    return ops
+
+
+def _standard_biothings_ops(biothing_type: str) -> set[tuple[str, str]]:
+    """The operations a stock BioThings API exposes for a given entity type."""
+    return {
+        ("GET", "/query"),
+        ("POST", "/query"),
+        ("GET", f"/{biothing_type}/{{}}"),
+        ("POST", f"/{biothing_type}"),
+        ("GET", "/metadata"),
+        ("GET", "/metadata/fields"),
+    }
+
+
+def analyze_biothings_spec(
+    spec: dict,
+) -> tuple[str | None, str | None, list[tuple[str, str]]]:
+    """Classify a BioThings spec for facade eligibility.
+
+    Returns ``(base_url, biothing_type, extra_ops)`` where ``extra_ops`` lists
+    operations that fall outside the standard BioThings interface. An empty
+    ``extra_ops`` (with a detected ``biothing_type``) means the API is fully
+    covered by the generic facade tools; otherwise it should be served with
+    faithful per-API tools so the extra endpoints aren't hidden.
+    """
+    try:
+        base_url = get_base_server_url(spec).rstrip("/")
+    except (KeyError, ValueError, TypeError):
+        base_url = None
+
+    biothing_type = None
+    for path in spec.get("paths", {}):
+        match = _BIOTHING_PATH_RE.match(path)
+        if match:
+            biothing_type = match.group("type")
+            break
+
+    ops = _spec_operations(spec)
+    if biothing_type is None:
+        extra = sorted(ops)
+    else:
+        extra = sorted(ops - _standard_biothings_ops(biothing_type))
+    return base_url, biothing_type, extra
+
+
+async def partition_biothings(
+    entries: dict[str, BioThingsAPIEntry],
+) -> tuple[dict[str, BioThingsAPIEntry], list[str]]:
+    """Split BioThings entries into facade-eligible vs. needs-per-API.
+
+    Loads each spec (in parallel) and classifies it with
+    :func:`analyze_biothings_spec`. Facade-eligible entries get their
+    ``base_url``/``biothing_type`` cached and are returned in the first dict;
+    APIs with extra endpoints, no detectable entity type, or an unloadable spec
+    are returned as a list of SmartAPI IDs to be served with per-API tools.
+    """
+    items = list(entries.items())
+    specs = await asyncio.gather(
+        *[asyncio.to_thread(load_api_spec, entry.smartapi_id) for _, entry in items],
+        return_exceptions=True,
+    )
+
+    facade_entries: dict[str, BioThingsAPIEntry] = {}
+    extra_ids: list[str] = []
+    for (name, entry), spec in zip(items, specs, strict=True):
+        if isinstance(spec, Exception):
+            logger.warning(
+                f"Could not load spec for BioThings API '{name}' "
+                f"({entry.smartapi_id}): {spec}; serving with per-API tools."
+            )
+            extra_ids.append(entry.smartapi_id)
+            continue
+        base_url, biothing_type, extra_ops = analyze_biothings_spec(spec)
+        if biothing_type is None or extra_ops:
+            reason = (
+                f"non-standard endpoint(s) {extra_ops}"
+                if extra_ops
+                else "no detectable entity type"
+            )
+            logger.info(
+                f"BioThings API '{name}' has {reason}; "
+                "serving it with faithful per-API tools."
+            )
+            extra_ids.append(entry.smartapi_id)
+        else:
+            entry.base_url = base_url
+            entry.biothing_type = biothing_type
+            facade_entries[name] = entry
+    return facade_entries, extra_ids
+
+
+def _score_entry(entry: BioThingsAPIEntry, tokens: list[str]) -> int:
+    """Lexical relevance: count token hits across title/description/tags."""
+    haystack = " ".join(
+        [entry.name, entry.title, entry.description, " ".join(entry.tags)]
+    ).lower()
+    return sum(haystack.count(token) for token in tokens)
+
+
+def rank_apis(
+    registry: dict[str, BioThingsAPIEntry],
+    keyword: str | None = None,
+    limit: int = 10,
+) -> list[dict]:
+    """Rank APIs by lexical relevance to ``keyword`` (returns plain data).
+
+    With no keyword, returns the full catalog sorted by name. Descriptions are
+    truncated to keep the payload small.
+    """
+
+    def _as_dict(entry: BioThingsAPIEntry) -> dict:
+        desc = entry.description
+        if len(desc) > _MAX_DESC_LEN:
+            desc = desc[:_MAX_DESC_LEN].rstrip() + "..."
+        return {
+            "name": entry.name,
+            "title": entry.title,
+            "description": desc,
+            "tags": entry.tags,
+        }
+
+    if not keyword or not keyword.strip():
+        return [_as_dict(registry[name]) for name in sorted(registry)]
+
+    tokens = [tok for tok in re.split(r"\W+", keyword.lower()) if tok]
+    scored = [(_score_entry(entry, tokens), entry) for entry in registry.values()]
+    scored = [pair for pair in scored if pair[0] > 0]
+    scored.sort(key=lambda pair: (-pair[0], pair[1].name))
+    return [{**_as_dict(entry), "score": score} for score, entry in scored[:limit]]
+
+
+def build_biothings_facade(
+    registry: dict[str, BioThingsAPIEntry], server_name: str = "smartapi_mcp"
+) -> FastMCP:
+    """Build a FastMCP server exposing generic BioThings tools over ``registry``."""
+    server = FastMCP(server_name)
+    valid_names = ", ".join(sorted(registry))
+    api_help = (
+        "BioThings API to target, given as its short name. "
+        "Call list_biothings_apis to discover APIs. "
+        f"Available: {valid_names}"
+    )
+
+    def _entry(api: str) -> BioThingsAPIEntry:
+        entry = registry.get(api)
+        if entry is None:
+            err_msg = (
+                f"Unknown api {api!r}. Valid values: {valid_names}. "
+                "Use list_biothings_apis to discover available APIs."
+            )
+            raise ValueError(err_msg)
+        _resolve_endpoints(entry)
+        return entry
+
+    async def _request(method: str, url: str, **kwargs) -> dict | list:
+        async with httpx.AsyncClient(timeout=HTTP_TIMEOUT) as client:
+            response = await client.request(method, url, **kwargs)
+            response.raise_for_status()
+            return response.json()
+
+    async def list_biothings_apis(
+        keyword: str | None = None, limit: int = 10
+    ) -> list[dict]:
+        """List/search the available BioThings APIs and return matching records."""
+        return rank_apis(registry, keyword, limit)
+
+    async def biothings_query(
+        api: str,
+        q: str,
+        fields: str = "all",
+        size: int = 10,
+        from_: int = 0,
+    ) -> dict | list:
+        """Search a BioThings API (GET /query)."""
+        entry = _entry(api)
+        params = {"q": q, "fields": fields, "size": size, "from": from_}
+        return await _request("GET", f"{entry.base_url}/query", params=params)
+
+    async def biothings_get(
+        api: str,
+        id: str,  # noqa: A002 - `id` is the natural BioThings parameter name
+        fields: str = "all",
+    ) -> dict | list:
+        """Retrieve a single annotation by id (GET /{type}/{id})."""
+        entry = _entry(api)
+        if not entry.biothing_type:
+            err_msg = f"Could not determine the entity type for api {api!r}."
+            raise ValueError(err_msg)
+        url = f"{entry.base_url}/{entry.biothing_type}/{id}"
+        return await _request("GET", url, params={"fields": fields})
+
+    async def biothings_getbatch(
+        api: str,
+        ids: list[str],
+        fields: str = "all",
+        scopes: str | None = None,
+    ) -> dict | list:
+        """Retrieve annotations for multiple ids (POST /{type})."""
+        entry = _entry(api)
+        if not entry.biothing_type:
+            err_msg = f"Could not determine the entity type for api {api!r}."
+            raise ValueError(err_msg)
+        data = {"ids": ",".join(ids), "fields": fields}
+        if scopes:
+            data["scopes"] = scopes
+        url = f"{entry.base_url}/{entry.biothing_type}"
+        return await _request("POST", url, data=data)
+
+    async def biothings_fields(api: str) -> dict | list:
+        """List the queryable/returnable fields for a BioThings API."""
+        entry = _entry(api)
+        return await _request("GET", f"{entry.base_url}/metadata/fields")
+
+    server.add_tool(
+        Tool.from_function(
+            list_biothings_apis,
+            name="list_biothings_apis",
+            description=(
+                f"Discover which of the {len(registry)} available BioThings APIs "
+                "to use. Optionally pass a keyword to rank by relevance. Returns "
+                "API names, titles, descriptions and tags. Call this first, then "
+                "pass a returned name as the `api` argument to the other tools."
+            ),
+        )
+    )
+    biothings_query.__doc__ = (
+        "Search a BioThings API. `api` is the API name (see list_biothings_apis); "
+        "`q` is a query string (e.g. 'symbol:CDK2' or 'diabetes')."
+    )
+    for func, name in (
+        (biothings_query, "biothings_query"),
+        (biothings_get, "biothings_get"),
+        (biothings_getbatch, "biothings_getbatch"),
+        (biothings_fields, "biothings_fields"),
+    ):
+        tool = Tool.from_function(func, name=name)
+        # Surface the list of valid `api` values in the tool description.
+        tool.description = f"{(func.__doc__ or '').strip()}\n\n{api_help}"
+        server.add_tool(tool)
+
+    logger.info(
+        f"Built BioThings facade '{server_name}' with {len(registry)} "
+        "APIs as 5 generic tools."
+    )
+    return server

{smartapi_mcp-0.2.0 → smartapi_mcp-0.3.0}/smartapi_mcp/cli.py

@@ -6,14 +6,16 @@ Provides CLI commands for running and managing the SmartAPI MCP server.
 
 import argparse
 import asyncio
+import signal
 import sys
 import traceback
 
 from awslabs.openapi_mcp_server import get_format, logger
-from awslabs.openapi_mcp_server.server import get_all_counts, setup_signal_handlers
+from awslabs.openapi_mcp_server.server import get_all_counts
+from awslabs.openapi_mcp_server.utils.metrics_provider import metrics
 
 from .config import load_config
-from .server import get_merged_mcp_server
+from .server import build_server_for_set
 
 
 def main():
@@ -23,8 +25,9 @@ def main():
     parser.add_argument(
         "--api_set",
         help=(
-            "the set of predefined SmartAPI APIs to include, e.g. 'biothings_core' "
-            "or 'biothings'."
+            "A predefined set of SmartAPI APIs to include. One of: "
+            "'biothings_core' (5 core BioThings APIs), 'biothings_test' "
+            "(core + SemmedDB), or 'biothings_all' (all BioThings APIs)."
         ),
     )
     parser.add_argument(
@@ -37,7 +40,10 @@ def main():
     )
     parser.add_argument(
         "--smartapi_q",
-        help="Pass a query string for a list of SmartAPIs to create a MCP server.",
+        help=(
+            "A SmartAPI registry search query selecting which APIs to include, "
+            "e.g. 'tags.name:biothings'."
+        ),
     )
     parser.add_argument(
         "--smartapi_exclude_ids",
@@ -63,6 +69,37 @@ def main():
         "--server_name",
         help='The name of the MCP server, default is "smartapi_mcp".',
     )
+    parser.add_argument(
+        "--facade",
+        choices=["auto", "on", "off"],
+        default="auto",
+        help=(
+            "How to expose large BioThings sets. The facade collapses BioThings "
+            "APIs into ~5 generic tools (the target API is a parameter); any "
+            "non-BioThings APIs in the set are added as per-API tools (hybrid). "
+            "'auto' (default): use the facade once there are enough BioThings "
+            "APIs (see --facade-threshold). 'on': always use it for BioThings "
+            "APIs. 'off': always emit faithful per-API tools for every API."
+        ),
+    )
+    parser.add_argument(
+        "--facade-threshold",
+        type=int,
+        default=10,
+        help=(
+            "Number of BioThings APIs in the set at which 'auto' switches to the "
+            "facade (default: 10)."
+        ),
+    )
+    parser.add_argument(
+        "--facade-strict",
+        action="store_true",
+        help=(
+            "Inspect BioThings specs and serve any API that has non-standard "
+            "endpoints (e.g. SemmedDB's /query/ngd) with faithful per-API tools "
+            "instead of the facade. Slower startup (downloads specs upfront)."
+        ),
+    )
     parser.add_argument(
         "--log-level",
         choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
@@ -80,20 +117,32 @@ def main():
     # Load configuration
     logger.debug("Loading configuration from arguments and environment")
     config = load_config(args)
+
     logger.debug("Configuration loaded.")
 
-    merged_server = asyncio.run(
-        get_merged_mcp_server(
-            smartapi_q=config.smartapi_q,
-            smartapi_id=config.smartapi_id,
-            smartapi_ids=config.smartapi_ids,
-            smartapi_exclude_ids=config.smartapi_exclude_ids,
-            api_set=config.smartapi_api_set,
-            server_name=config.server_name,
+    try:
+        merged_server = asyncio.run(
+            build_server_for_set(
+                smartapi_q=config.smartapi_q,
+                smartapi_id=config.smartapi_id,
+                smartapi_ids=config.smartapi_ids,
+                smartapi_exclude_ids=config.smartapi_exclude_ids,
+                api_set=config.smartapi_api_set,
+                server_name=config.server_name,
+                facade=getattr(config, "facade", "auto"),
+                facade_threshold=getattr(config, "facade_threshold", 10),
+                facade_strict=getattr(config, "facade_strict", False),
+            )
         )
-    )
+    except ValueError as e:
+        logger.error(f"Cannot start server: {e}")
+        logger.error(
+            "Specify which APIs to serve with one of: --api_set, --smartapi_id, "
+            "--smartapi_ids, or --smartapi_q (see --help)."
+        )
+        sys.exit(1)
 
-    # Set up signal handlers
+    # Set up signal handlers (local implementation avoids sys.exit in handler)
     setup_signal_handlers()
 
     try:
@@ -134,5 +183,37 @@ def main():
     merged_server.run()
 
 
+def setup_signal_handlers() -> None:
+    """
+    Set up signal handlers for graceful shutdown without sys.exit.
+    Modified from awslabs.openapi_mcp_server.server.setup_signal_handlers
+    Original version calls sys.exit in the handler which can cause issues.
+    """
+    handled = {"done": False}
+
+    def _handler(sig, frame):  # noqa: ARG001
+        if handled["done"]:
+            return
+        handled["done"] = True
+
+        logger.debug("Received signal %s, shutting down gracefully...", sig)
+
+        # Log final metrics
+        summary = metrics.get_summary()
+        logger.info(f"Final metrics: {summary}")
+
+        if sig == signal.SIGINT:
+            logger.info("Process Interrupted, Shutting down gracefully...")
+
+        logger.info("Shutdown complete.")
+
+        # Restore default handler and re-raise signal to let runtime unwind cleanly
+        signal.signal(sig, signal.SIG_DFL)
+        signal.raise_signal(sig)
+
+    signal.signal(signal.SIGTERM, _handler)
+    signal.signal(signal.SIGINT, _handler)
+
+
 if __name__ == "__main__":
     main()

{smartapi_mcp-0.2.0 → smartapi_mcp-0.3.0}/smartapi_mcp/config.py

@@ -14,7 +14,21 @@ class Config(_config.Config):
     smartapi_exclude_ids: list[str] | None = None
     smartapi_q: str = ""
     smartapi_api_set: str = ""
-    server_name: str = "smartapi-mcp"
+    server_name: str = "smartapi_mcp"
+    facade: str = "auto"
+    facade_threshold: int = 10
+    facade_strict: bool = False
+
+
+def _parse_bool(value: str) -> bool:
+    return value.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _parse_int(value: str, default: int) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
 
 
 def load_config(args: Any = None) -> Config:
@@ -32,6 +46,11 @@ def load_config(args: Any = None) -> Config:
         ),
         "SMARTAPI_Q": (lambda v: setattr(config, "smartapi_q", v)),
         "SMARTAPI_API_SET": (lambda v: setattr(config, "smartapi_api_set", v)),
+        "SMARTAPI_FACADE": (lambda v: setattr(config, "facade", v.strip().lower())),
+        "FACADE_THRESHOLD": (
+            lambda v: setattr(config, "facade_threshold", _parse_int(v, 10))
+        ),
+        "FACADE_STRICT": (lambda v: setattr(config, "facade_strict", _parse_bool(v))),
         "SERVER_NAME": (lambda v: setattr(config, "server_name", v)),
     }
 
@@ -83,6 +102,12 @@ def load_config(args: Any = None) -> Config:
         if hasattr(args, "server_name") and args.server_name:
             logger.debug(f"Setting MCP Server name from arguments: {args.server_name}")
             config.server_name = args.server_name
+        if getattr(args, "facade", None):
+            config.facade = str(args.facade).strip().lower()
+        if getattr(args, "facade_threshold", None):
+            config.facade_threshold = int(args.facade_threshold)
+        if getattr(args, "facade_strict", False):
+            config.facade_strict = True
         if hasattr(args, "transport") and args.transport:
             logger.debug(
                 f"Setting MCP Server transport mode from arguments: {args.transport}"

smartapi_mcp-0.3.0/smartapi_mcp/server.py

@@ -0,0 +1,256 @@
+"""
+SmartAPI MCP Server
+
+Main MCP server implementation for SmartAPI integration.
+"""
+
+import re
+
+from awslabs.openapi_mcp_server import logger
+from awslabs.openapi_mcp_server.api.config import Config
+from awslabs.openapi_mcp_server.server import create_mcp_server_async
+from fastmcp import FastMCP
+
+# Import BioThings generic-facade builder
+from .biothings import build_biothings_facade, build_registry, partition_biothings
+
+# Import from smartapi module - avoiding circular imports
+from .smartapi import (
+    get_base_server_url,
+    get_predefined_api_set,
+    get_smartapi_ids,
+    load_api_spec,
+    smartapi_spec_url,
+)
+
+
+async def get_mcp_server(smartapi_id: str) -> FastMCP:
+    config = Config(
+        api_spec_url=smartapi_spec_url.format(smartapi_id=smartapi_id),
+    )
+    openapi_spec = load_api_spec(smartapi_id)
+    base_server_url = get_base_server_url(openapi_spec)
+    config.api_base_url = base_server_url
+
+    return await create_mcp_server_async(config)
+
+
+async def _merge_servers_into(
+    target: FastMCP, list_of_servers: list[FastMCP]
+) -> FastMCP:
+    """Add the tools/prompts of each server to ``target``, prefixed by API name.
+
+    Tool and prompt names are prefixed with the source server's (API) name to
+    avoid conflicts. ``target`` is mutated in place and returned.
+    """
+    for server in list_of_servers:
+        api_name = re.sub(
+            r"[^a-z0-9_-]", "_", getattr(server, "name", "unknown_api").lower()
+        )
+
+        tools = await server.get_tools()
+        if tools:
+            for original_name, tool in tools.items():
+                # Rename the tool by prefixing with API name
+                tool.name = f"{api_name}_{original_name}"
+                target.add_tool(tool)
+        else:
+            err_msg = f"Server {server} does not have accessible tools."
+            raise AttributeError(err_msg)
+
+        # Merge prompts
+        prompts = await server.get_prompts()
+        if prompts:
+            for original_name, prompt in prompts.items():
+                # Rename the prompt by prefixing with API name
+                prompt.name = f"{api_name}_{original_name}"
+                target.add_prompt(prompt)
+            logger.debug(f"Merged {len(prompts)} prompts from {api_name}")
+
+    return target
+
+
+async def merge_mcp_servers(
+    list_of_servers: list[FastMCP], merged_name: str = "merged_mcp"
+) -> FastMCP:
+    """
+    Merges a list of FastMCP instances into
+    a single FastMCP instance by combining their
+    tools, prefixing tool names with the server's
+    name (API name) to avoid conflicts.
+
+    Args:
+        list_of_servers: List of FastMCP instances to merge.
+        merged_name: Name for the merged FastMCP instance.
+
+    Returns:
+        A new FastMCP instance with renamed tools from all input servers.
+    """
+    return await _merge_servers_into(FastMCP(merged_name), list_of_servers)
+
+
+async def get_merged_mcp_server(
+    smartapi_q: str | None = None,
+    smartapi_id: str | None = None,
+    smartapi_ids: list[str] | None = None,
+    smartapi_exclude_ids: list[str] | None = None,
+    api_set: str | None = None,
+    server_name: str = "smartapi_mcp",
+) -> FastMCP:
+    logger.debug(f"api_set: {api_set}")
+    if api_set:
+        api_set_args = get_predefined_api_set(api_set)
+        if "smartapi_ids" in api_set_args:
+            smartapi_ids = api_set_args["smartapi_ids"]
+        if "smartapi_q" in api_set_args:
+            smartapi_q = api_set_args["smartapi_q"]
+        if "smartapi_exclude_ids" in api_set_args:
+            smartapi_exclude_ids = api_set_args["smartapi_exclude_ids"]
+        logger.debug(f"api_set_args: {api_set_args}")
+    logger.debug(f"smartapi_ids: {smartapi_ids}")
+    logger.debug(f"smartapi_q: {smartapi_q}")
+    logger.debug(f"smartapi_exclude_ids: {smartapi_exclude_ids}")
+    if smartapi_q:
+        smartapi_ids = await get_smartapi_ids(smartapi_q)
+    if smartapi_id:
+        smartapi_ids = [smartapi_id]
+    if smartapi_ids:
+        smartapi_ids = list(set(smartapi_ids))
+    if not smartapi_ids:
+        err_msg = "No SmartAPI IDs provided or found with the given query."
+        raise ValueError(err_msg)
+    smartapi_exclude_ids = smartapi_exclude_ids or []
+    list_of_servers = [
+        await get_mcp_server(sid)
+        for sid in smartapi_ids
+        if sid not in smartapi_exclude_ids
+    ]
+    merged_server = await merge_mcp_servers(list_of_servers, server_name)
+    logger.info(f"Merged {len(list_of_servers)} APIs into one MCP server.")
+    return merged_server
+
+
+async def _resolve_smartapi_ids(
+    smartapi_q: str | None = None,
+    smartapi_id: str | None = None,
+    smartapi_ids: list[str] | None = None,
+    smartapi_exclude_ids: list[str] | None = None,
+    api_set: str | None = None,
+) -> list[str]:
+    """Resolve the various ID sources into a deduped, exclusion-filtered list."""
+    if api_set:
+        api_set_args = get_predefined_api_set(api_set)
+        smartapi_ids = api_set_args.get("smartapi_ids", smartapi_ids)
+        smartapi_q = api_set_args.get("smartapi_q", smartapi_q)
+        smartapi_exclude_ids = api_set_args.get(
+            "smartapi_exclude_ids", smartapi_exclude_ids
+        )
+
+    if smartapi_q:
+        smartapi_ids = await get_smartapi_ids(smartapi_q)
+    if smartapi_id:
+        smartapi_ids = [smartapi_id]
+
+    if smartapi_ids:
+        # Dedupe while preserving order (stable, unlike set()).
+        smartapi_ids = list(dict.fromkeys(smartapi_ids))
+    if not smartapi_ids:
+        err_msg = "No SmartAPI IDs provided or found with the given query."
+        raise ValueError(err_msg)
+
+    exclude = set(smartapi_exclude_ids or [])
+    return [sid for sid in smartapi_ids if sid not in exclude]
+
+
+async def build_server_for_set(
+    smartapi_q: str | None = None,
+    smartapi_id: str | None = None,
+    smartapi_ids: list[str] | None = None,
+    smartapi_exclude_ids: list[str] | None = None,
+    api_set: str | None = None,
+    server_name: str = "smartapi_mcp",
+    *,
+    facade: str = "auto",
+    facade_threshold: int = 10,
+    facade_strict: bool = False,
+) -> FastMCP:
+    """Build the MCP server for an API set, picking the right strategy.
+
+    For large BioThings sets the **generic facade** (a fixed ~5 tools where the
+    target API is a parameter) is used to avoid the 200+ per-API tool explosion.
+    For a **mixed** set, the result is a *hybrid* server: the BioThings APIs are
+    served through the facade while any non-BioThings APIs are added as faithful
+    per-API tools in the same server, so nothing is lost. ``facade`` is one of
+    ``"auto"`` (facade when enough APIs in the set are BioThings),
+    ``"on"`` (force facade for the BioThings subset), or ``"off"`` (always emit
+    per-API tools for every API).
+
+    ``facade_strict`` (default ``False``) controls handling of the rare
+    BioThings APIs that expose endpoints beyond the standard interface (e.g.
+    SemmedDB's ``/query/ngd``). When ``False``, all BioThings APIs go through the
+    facade and those extra endpoints are not reachable (fast startup, no spec
+    downloads). When ``True``, each BioThings spec is inspected and any API with
+    extra endpoints is served with faithful per-API tools instead (slower
+    startup; downloads specs upfront).
+    """
+    available_ids = await _resolve_smartapi_ids(
+        smartapi_q=smartapi_q,
+        smartapi_id=smartapi_id,
+        smartapi_ids=smartapi_ids,
+        smartapi_exclude_ids=smartapi_exclude_ids,
+        api_set=api_set,
+    )
+
+    if facade != "off":
+        registry = await build_registry(available_ids)
+        biothings = {
+            name: entry for name, entry in registry.items() if "biothings" in entry.tags
+        }
+        if facade == "on" and not biothings:
+            logger.warning(
+                "facade='on' but no BioThings APIs were found in the set; "
+                "falling back to per-API tools."
+            )
+        use_facade = bool(biothings) and (
+            facade == "on" or len(biothings) >= facade_threshold
+        )
+        if use_facade:
+            if facade_strict:
+                # Inspect specs: only fully-standard BioThings APIs go in the
+                # facade; ones with extra endpoints fall back to per-API tools.
+                facade_entries, extra_bt_ids = await partition_biothings(biothings)
+            else:
+                # Fast path: assume every BioThings API is fully standard.
+                facade_entries, extra_bt_ids = biothings, []
+            non_biothings_ids = [
+                entry.smartapi_id
+                for name, entry in registry.items()
+                if name not in biothings
+            ]
+            per_api_ids = non_biothings_ids + extra_bt_ids
+
+            if facade_entries:
+                server = build_biothings_facade(facade_entries, server_name)
+                if per_api_ids:
+                    logger.info(
+                        f"Hybrid server: facade over {len(facade_entries)} "
+                        f"BioThings API(s) + per-API tools for "
+                        f"{len(per_api_ids)} other API(s)."
+                    )
+                    extra_servers = [await get_mcp_server(sid) for sid in per_api_ids]
+                    await _merge_servers_into(server, extra_servers)
+                else:
+                    logger.info(
+                        f"Using BioThings facade for {len(facade_entries)} APIs "
+                        f"(server_name={server_name})."
+                    )
+                return server
+            logger.info(
+                "No APIs qualified for the BioThings facade; using per-API tools."
+            )
+
+    logger.info(f"Using per-API tools for {len(available_ids)} APIs.")
+    return await get_merged_mcp_server(
+        smartapi_ids=available_ids,
+        server_name=server_name,
+    )

{smartapi_mcp-0.2.0 → smartapi_mcp-0.3.0}/smartapi_mcp/smartapi.py

@@ -12,27 +12,65 @@ from awslabs.openapi_mcp_server.api.config import Config
 from awslabs.openapi_mcp_server.utils.openapi import load_openapi_spec
 from awslabs.openapi_mcp_server.utils.openapi_validator import validate_openapi_spec
 
-smartapi_query_url = "https://smart-api.info/api/query?q={q}&fields=_id&size=500&raw=1"
-
-
-async def get_smartapi_ids(q: str) -> list:
-    """Give a query string, return a list of SmartAPI IDs matching the query."""
-    _url = smartapi_query_url.format(q=q)
+smartapi_query_url = "https://smart-api.info/api/query"
+smartapi_spec_url = "https://smart-api.info/api/metadata/{smartapi_id}"
+
+# Default timeout (seconds) for all SmartAPI registry HTTP calls.
+HTTP_TIMEOUT = 30.0
+
+
+async def get_smartapi_registry(
+    q: str | None = None, ids: list[str] | None = None
+) -> list[dict]:
+    """Query the SmartAPI registry and return metadata for matching APIs.
+
+    Returns a list of ``{"_id", "title", "description", "tags"}`` dicts. Pass
+    either a query string ``q`` or an explicit list of ``ids`` (which is turned
+    into an ``_id:(...)`` query so a whole set is fetched in a single request).
+    """
+    if ids:
+        q = "_id:({})".format(" OR ".join(ids))
+    if not q:
+        err_msg = "Either a query string or a list of IDs must be provided."
+        raise ValueError(err_msg)
 
-    smartapi_ids = []
-    async with httpx.AsyncClient() as client:
-        response = await client.get(_url)
+    params = {
+        "q": q,
+        "fields": "info.title,info.description,tags",
+        "size": 500,
+        "raw": 1,
+    }
+    async with httpx.AsyncClient(timeout=HTTP_TIMEOUT) as client:
+        response = await client.get(smartapi_query_url, params=params)
         response.raise_for_status()
         data = response.json()
-        for api in data["hits"]:
-            smartapi_id = api["_id"]
-            smartapi_ids.append(smartapi_id)
-    return smartapi_ids
+
+    entries: list[dict] = []
+    for hit in data.get("hits", []):
+        info = hit.get("info", {}) or {}
+        tags = [
+            tag.get("name", "") for tag in hit.get("tags", []) if isinstance(tag, dict)
+        ]
+        entries.append(
+            {
+                "_id": hit.get("_id", ""),
+                "title": info.get("title", ""),
+                "description": info.get("description", ""),
+                "tags": [tag for tag in tags if tag],
+            }
+        )
+    return entries
+
+
+async def get_smartapi_ids(q: str) -> list[str]:
+    """Give a query string, return a list of SmartAPI IDs matching the query."""
+    entries = await get_smartapi_registry(q=q)
+    return [entry["_id"] for entry in entries if entry["_id"]]
 
 
 def load_api_spec(smartapi_id: str) -> dict:
     config = Config(
-        api_spec_url=f"https://smart-api.info/api/metadata/{smartapi_id}",
+        api_spec_url=smartapi_spec_url.format(smartapi_id=smartapi_id),
     )
     api_spec = load_openapi_spec(url=config.api_spec_url)
 
@@ -108,6 +146,7 @@ def get_predefined_api_set(api_set: str) -> dict:
                 "cc857d5b7c8b7609b5bbb38ff990bfff",  # GO Biological Process API
                 "f339b28426e7bf72028f60feefcd7465",  # GO Cellular Component API
                 "34bad236d77bea0a0ee6c6cba5be54a6",  # GO Molecular Function API
+                "27a5b60716c3a401f2c021a5b718c5b1",  # SmartAPI registry API
             ],
         }
     err_msg = f"Unknown API set: {api_set}"

{smartapi_mcp-0.2.0 → smartapi_mcp-0.3.0}/smartapi_mcp.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ requirements.txt
 setup.py
 smartapi_mcp/__init__.py
 smartapi_mcp/__main__.py
+smartapi_mcp/biothings.py
 smartapi_mcp/cli.py
 smartapi_mcp/config.py
 smartapi_mcp/py.typed

smartapi_mcp-0.2.0/smartapi_mcp/server.py

@@ -1,121 +0,0 @@
-"""
-SmartAPI MCP Server
-
-Main MCP server implementation for SmartAPI integration.
-"""
-
-import re
-
-from awslabs.openapi_mcp_server import logger
-from awslabs.openapi_mcp_server.api.config import Config
-from awslabs.openapi_mcp_server.server import create_mcp_server_async
-from fastmcp import FastMCP
-
-from .smartapi import (
-    get_base_server_url,
-    get_predefined_api_set,
-    get_smartapi_ids,
-    load_api_spec,
-)
-
-
-async def get_mcp_server(smartapi_id: str) -> FastMCP:
-    config = Config(
-        api_spec_url=f"https://smart-api.info/api/metadata/{smartapi_id}",
-    )
-    openapi_spec = load_api_spec(smartapi_id)
-    base_server_url = get_base_server_url(openapi_spec)
-    config.api_base_url = base_server_url
-
-    return await create_mcp_server_async(config)
-
-
-async def merge_mcp_servers(
-    list_of_servers: list[FastMCP], merged_name: str = "merged_mcp"
-) -> FastMCP:
-    """
-    Merges a list of FastMCP instances into
-    a single FastMCP instance by combining their
-    tools, prefixing tool names with the server's
-    name (API name) to avoid conflicts.
-
-    Args:
-        list_of_servers: List of FastMCP instances to merge.
-        merged_name: Name for the merged FastMCP instance.
-
-    Returns:
-        A new FastMCP instance with renamed tools from all input servers.
-    """
-    merged_mcp = FastMCP(merged_name)
-
-    for server in list_of_servers:
-        api_name = re.sub(
-            r"[^a-z0-9_-]", "_", getattr(server, "name", "unknown_api").lower()
-        )
-
-        tools = await server.get_tools()
-        if tools:
-            for original_name, tool in tools.items():
-                # Rename the tool by prefixing with API name
-                new_name = f"{api_name}_{original_name}"
-                tool.name = new_name  # Modify the tool's name attribute
-
-                # Add the renamed tool to the merged instance
-                merged_mcp.add_tool(tool)
-        else:
-            err_msg = f"Server {server} does not have accessible tools."
-            raise AttributeError(err_msg)
-
-        # Merge prompts
-        prompts = await server.get_prompts()
-        if prompts:
-            for original_name, prompt in prompts.items():
-                # Rename the prompt by prefixing with API name
-                new_name = f"{api_name}_{original_name}"
-                prompt.name = new_name  # Modify the prompt's name attribute
-                # Add the renamed prompt to the merged instance
-                merged_mcp.add_prompt(prompt)
-            logger.debug(f"Merged {len(prompts)} prompts from {api_name}")
-
-    return merged_mcp
-
-
-async def get_merged_mcp_server(
-    smartapi_q: str | None = None,
-    smartapi_id: str | None = None,
-    smartapi_ids: list[str] | None = None,
-    smartapi_exclude_ids: list[str] | None = None,
-    api_set: str | None = None,
-    server_name: str = "smartapi_mcp",
-) -> FastMCP:
-    logger.debug(f"api_set: {api_set}")
-    if api_set:
-        api_set_args = get_predefined_api_set(api_set)
-        if "smartapi_ids" in api_set_args:
-            smartapi_ids = api_set_args["smartapi_ids"]
-        if "smartapi_q" in api_set_args:
-            smartapi_q = api_set_args["smartapi_q"]
-        if "smartapi_exclude_ids" in api_set_args:
-            smartapi_exclude_ids = api_set_args["smartapi_exclude_ids"]
-        logger.debug(f"api_set_args: {api_set_args}")
-    logger.debug(f"smartapi_ids: {smartapi_ids}")
-    logger.debug(f"smartapi_q: {smartapi_q}")
-    logger.debug(f"smartapi_exclude_ids: {smartapi_exclude_ids}")
-    if smartapi_q:
-        smartapi_ids = await get_smartapi_ids(smartapi_q)
-    if smartapi_id:
-        smartapi_ids = [smartapi_id]
-    if smartapi_ids:
-        smartapi_ids = list(set(smartapi_ids))
-    if not smartapi_ids:
-        err_msg = "No SmartAPI IDs provided or found with the given query."
-        raise ValueError(err_msg)
-    smartapi_exclude_ids = smartapi_exclude_ids or []
-    list_of_servers = [
-        await get_mcp_server(sid)
-        for sid in smartapi_ids
-        if sid not in smartapi_exclude_ids
-    ]
-    merged_server = await merge_mcp_servers(list_of_servers, server_name)
-    logger.info(f"Merged {len(list_of_servers)} APIs into one MCP server.")
-    return merged_server