Skip to main content
Glama
biocontext-ai

BioContextAI Knowledgebase MCP

Official

bc_get_antibody_information

Retrieve detailed antibody specifications including catalog numbers, vendor, clonality, epitope, applications, and target species by providing an Antibody Registry ID.

Instructions

Get detailed antibody information by ID. Retrieves catalog number, vendor, clonality, epitope, applications, and more.

Returns: dict: Antibody details including abId, catalog numbers, vendor, clonality, epitope, applications, target species, isotype, citations or error message.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
ab_idYesAntibody Registry ID (e.g., '3643095')

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Implementation Reference

  • The core handler function for the 'bc_get_antibody_information' tool (prefixed by 'BC' server name). Fetches detailed antibody information from the Antibody Registry API given an antibody ID.
    @core_mcp.tool()
    def get_antibody_information(
        ab_id: Annotated[str, Field(description="Antibody Registry ID (e.g., '3643095')")],
    ) -> dict:
        """Get detailed antibody information by ID. Retrieves catalog number, vendor, clonality, epitope, applications, and more.
    
        Returns:
            dict: Antibody details including abId, catalog numbers, vendor, clonality, epitope, applications, target species, isotype, citations or error message.
        """
        ab_id = ab_id.strip()
        if not ab_id:
            return {"error": "Antibody ID cannot be empty."}
    
        url = f"https://www.antibodyregistry.org/api/antibodies/{ab_id}"
    
        headers = {"accept": "application/json"}
    
        try:
            response = requests.get(url, headers=headers)
            response.raise_for_status()
            result = response.json()
    
            # API returns an array of antibodies
            if isinstance(result, list):
                if len(result) > 0:
                    # Return the first item from the array
                    return result[0]
                else:
                    return {"error": f"No data found for antibody ID: {ab_id}"}
            else:
                return {"error": "Unexpected result format from Antibody Registry query."}
    
        except requests.exceptions.RequestException as e:
            return {"error": f"Failed to fetch antibody information from Antibody Registry: {e!s}"}
  • Star import from antibodyregistry module, which imports and registers the get_antibody_information tool via its @core_mcp.tool() decorator.
    from .biorxiv import *
  • Imports the handler function into the package namespace to enable registration when imported from core/__init__.py
    from ._get_antibody_information import get_antibody_information
    from ._get_antibody_list import get_antibody_list
  • Defines the core_mcp FastMCP instance with name 'BC', which prefixes all registered tools with 'bc_' (e.g., bc_get_antibody_information).
    from fastmcp import FastMCP
    
    core_mcp = FastMCP(  # type: ignore
        "BC",
        instructions="Provides access to biomedical knowledge bases.",
    )
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 specifies the action ('Get detailed antibody information') and return format ('dict: Antibody details... or error message'), which covers basic read-only behavior and error handling. However, it lacks details on rate limits, authentication requirements, data freshness, or whether the operation is idempotent—important context for a retrieval tool.

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 well-structured and front-loaded: the first sentence states the core purpose, followed by specifics of what's retrieved, and ends with return details. It avoids redundancy and uses clear, technical language. However, the 'Returns:' section could be integrated more smoothly, and there's minor verbosity in listing fields ('catalog numbers, vendor, clonality...').

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 simplicity (1 parameter, 100% schema coverage, output schema exists), the description is reasonably complete. It explains what the tool does, what information it returns, and hints at error handling. With an output schema, it needn't detail return values extensively. The main gap is lack of usage guidelines, but for a straightforward lookup tool, this is less critical.

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

Parameters3/5

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

The input schema has 100% description coverage, with 'ab_id' documented as 'Antibody Registry ID (e.g., '3643095')'. The description adds no additional parameter semantics beyond what the schema provides (e.g., format constraints, validation rules, or examples). Since schema coverage is high, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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: 'Get detailed antibody information by ID' with specific examples of what information is retrieved (catalog number, vendor, clonality, epitope, applications, and more). It distinguishes from the sibling 'bc_get_antibody_list' by focusing on detailed information for a specific antibody rather than listing antibodies. However, it doesn't explicitly contrast with other siblings like 'bc_get_alphafold_info_by_protein_symbol' which serves a different biological domain.

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

Usage Guidelines2/5

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an Antibody Registry ID), nor does it differentiate from similar tools like 'bc_get_antibody_list' (for listing vs. detailed info) or other data retrieval tools in the sibling set. The agent must infer usage from the name and description alone.

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/biocontext-ai/knowledgebase-mcp'

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