Skip to main content
Glama

romm_library_items

Browse and filter ROMs in your library by platform, search terms, or favorites, with pagination and sorting options.

Instructions

Browse ROMs — filter by platform, search term, or favorites. Paginated.

platform_id: Filter to a single platform (use romm_platforms to find IDs). 0 = all. search: Text search in ROM names. favorite: Show only favorites (default: false). limit: Items per page (default 25, max 100). offset: Skip this many items (default 0). order_by: Sort field — "name", "fs_size_bytes", "updated_at" (default: name). order_dir: "asc" or "desc" (default: asc).

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
platform_idNo
searchNo
favoriteNo
limitNo
offsetNo
order_byNoname
order_dirNoasc

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Implementation Reference

  • The handler function for romm_library_items which fetches ROMs from the Romm API, processes the output, and formats it for the user.
    async def romm_library_items(
        platform_id: int = 0,
        search: str = "",
        favorite: bool = False,
        limit: int = 25,
        offset: int = 0,
        order_by: str = "name",
        order_dir: str = "asc",
    ) -> str:
        """Browse ROMs — filter by platform, search term, or favorites. Paginated.
    
        platform_id: Filter to a single platform (use romm_platforms to find IDs). 0 = all.
        search: Text search in ROM names.
        favorite: Show only favorites (default: false).
        limit: Items per page (default 25, max 100).
        offset: Skip this many items (default 0).
        order_by: Sort field — "name", "fs_size_bytes", "updated_at" (default: name).
        order_dir: "asc" or "desc" (default: asc).
        """
        limit = min(max(limit, 1), 100)
        params: dict = {
            "limit": limit,
            "offset": offset,
            "order_by": order_by,
            "order_dir": order_dir,
        }
        if platform_id:
            params["platform_ids"] = platform_id
        if search:
            params["search_term"] = search
        if favorite:
            params["favorite"] = True
    
        data = await _get("roms", params=params, long_timeout=True)
    
        items = []
        if isinstance(data, dict):
            items = data.get("items", [])
        elif isinstance(data, list):
            items = data
    
        if not items:
            qualifier = f" matching \"{search}\"" if search else ""
            qualifier += f" on platform {platform_id}" if platform_id else ""
            return f"No ROMs found{qualifier}."
    
        total = len(items)
        lines = [f"ROMs (offset {offset}, showing {total}):\n"]
        for i, rom in enumerate(items, 1):
            lines.extend(_fmt_rom_line(rom, index=i + offset))
    
        return "\n".join(lines)
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions pagination and default values for parameters, which adds useful context. However, it doesn't cover critical aspects like whether this is a read-only operation, potential rate limits, authentication requirements, error handling, or what the output looks like (though an output schema exists).

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized and front-loaded with the core purpose in the first sentence, followed by detailed parameter explanations. Every sentence adds value, though the parameter explanations could be slightly more structured (e.g., bullet points). There's no redundant information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (7 parameters, paginated browsing) and the presence of an output schema (which handles return values), the description is mostly complete. It covers the purpose, filtering options, pagination, and detailed parameter semantics. The main gaps are lack of behavioral context (e.g., read-only status, errors) and explicit differentiation from sibling tools.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description provides comprehensive parameter semantics beyond the input schema, which has 0% description coverage. It explains each parameter's purpose, defaults, constraints (e.g., 'max 100' for limit), and usage notes (e.g., '0 = all' for platform_id, referencing 'romm_platforms' for IDs). This fully compensates for the schema's lack of descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Browse ROMs — filter by platform, search term, or favorites. Paginated.' It specifies the verb ('browse') and resource ('ROMs') with filtering capabilities. However, it doesn't explicitly differentiate from sibling tools like 'romm_search' or 'romm_get_item', which likely have overlapping functionality.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides some implied usage context by mentioning filtering options and pagination, and it references 'romm_platforms' to find IDs for the platform_id parameter. However, it lacks explicit guidance on when to use this tool versus alternatives like 'romm_search' or 'romm_get_item', and it doesn't specify prerequisites or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/lodordev/mcp-romm'

If you have feedback or need assistance with the MCP directory API, please join our Discord server