Skip to main content
Glama

Check symbols and kwargs against an installed version

check_symbols
Read-onlyIdempotent

Validate intended Python symbols and keyword arguments against a package version before execution; returns present/missing status, rejected kwargs, deprecation notes, and hints.

Instructions

Batch-check that symbols, and the keyword arguments you plan to pass, exist in a specific version of a package. Returns present/missing per symbol (unknown where the index can't tell, with the reason), rejected kwargs, deprecation notes, and hints. Use it to preflight code against the version you have installed: pass the symbols, or the code itself. For one symbol across all releases use symbol_history, and after an exception use explain_error.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "package": "<package>",
      "version": "<version>"
    },
    "name": "check_symbols"
  }
}

Input Schema

NameRequiredDescriptionDefault
codeNoPython code to check instead of, or as well as, `symbols`: the package names it imports, the attributes it reads off them and the keyword arguments it passes are read with `ast` (never run).
packageYesPyPI distribution name, e.g. 'langchain-core'.
symbolsNoUp to 100 symbols, each a public dotted path plus the keyword arguments you plan to pass.
versionYesInstalled version, e.g. '0.28.1'.

Output Schema

NameRequiredDescriptionDefault
noteNo
exactYes
packageYes
resultsYes
resolved_versionYesNearest indexed version <= requested_version.
requested_versionYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed3 schema fields changedv0.1.13
    • changedInput schema / $defs / SymbolQuery / properties / positional / description
      Previous value: -"How many arguments the call passes by position, if you know (DT-CORE-34): then a required parameter it passes neither way is listed in `missing_args`."New value: +"How many arguments the call passes by position, if you know (DT-CORE-34): then a required parameter it passes neither way is listed in `missing_args`, and passing more than the signature takes sets `max_positional` (DT-CORE-50)."
    • addedOutput schema / $defs / SymbolCheck / properties / max_positional
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "integer"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "description": "Set when the call passes more arguments by position (`positional`) than the callable takes at this version, which has no `*args` (DT-CORE-50): the most it takes, a method's instance not counted. The call fails with TypeError; `hint` names the last indexed release that took them all. A method reached through its class (`Base.__init__(self, x)`) may be passed its instance explicitly, so one argument more isn't flagged there.",
      +  "title": "Max Positional"
      +}
    • addedOutput schema / $defs / SymbolCheck / properties / raises
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "description": "When the callable's body, at this version, does nothing but raise: the exception and its message (`TypeError: cannot sort an Index object in-place, use sort_values instead`). Calling it fails though the name is present. Text mined from the library source: untrusted data.",
      +  "title": "Raises"
      +}
  2. Changed4 schema fields changedv0.1.10
    • addedInput schema / $defs / SymbolQuery / properties / positional
      Added value: +{
      +  "anyOf": [
      +    {
      +      "minimum": 0,
      +      "type": "integer"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "description": "How many arguments the call passes by position, if you know (DT-CORE-34): then a required parameter it passes neither way is listed in `missing_args`.",
      +  "title": "Positional"
      +}
    • addedOutput schema / $defs / SymbolCheck / properties / missing_args
      Added value: +{
      +  "description": "Required parameters the call doesn't pass, from `positional` and `kwargs` (DT-CORE-34); empty when `positional` isn't given.",
      +  "items": {
      +    "type": "string"
      +  },
      +  "title": "Missing Args",
      +  "type": "array"
      +}
    • addedOutput schema / $defs / SymbolCheck / properties / status / description
      Added value: +"unknown: the index can't tell, and `hint` says why: the path goes through an object whose attributes are made at runtime (`pytest.mark`, `django.conf.settings`), or into a distribution DepTime doesn't index."
    • changedOutput schema / $defs / SymbolCheck / properties / status / enum
      Previous value: -[
      -  "present",
      -  "missing",
      -  "not_indexed"
      -]New value: +[
      +  "present",
      +  "missing",
      +  "not_indexed",
      +  "unknown"
      +]
  3. Changed7 schema fields changedv0.1.8
    • addedInput schema / properties / code
      Added value: +{
      +  "anyOf": [
      +    {
      +      "maxLength": 100000,
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "description": "Python code to check instead of, or as well as, `symbols`: the package names it imports, the attributes it reads off them and the keyword arguments it passes are read with `ast` (never run).",
      +  "title": "Code"
      +}
    • addedInput schema / properties / symbols / anyOf
      Added value: +[
      +  {
      +    "items": {
      +      "$ref": "#/$defs/SymbolQuery"
      +    },
      +    "maxItems": 100,
      +    "type": "array"
      +  },
      +  {
      +    "type": "null"
      +  }
      +]
    • addedInput schema / properties / symbols / default
      Added value: +null
    • removedInput schema / properties / symbols / items
      Removed value: -{
      -  "$ref": "#/$defs/SymbolQuery"
      -}
    • removedInput schema / properties / symbols / maxItems
      Removed value: -100
    • removedInput schema / properties / symbols / type
      Removed value: -"array"
    • changedInput schema / required
      Previous value: -[
      -  "package",
      -  "version",
      -  "symbols"
      -]New value: +[
      +  "package",
      +  "version"
      +]
  4. Changed1 schema field changedv0.1.5
    • addedOutput schema / $defs / SymbolCheck / properties / internal
      Added value: +{
      +  "default": false,
      +  "description": "True when the name isn't public API: a private name, a name a module imports for its own use, or a name in a private module. Code that uses one, usually another library, breaks when it changes, with no deprecation first.",
      +  "title": "Internal",
      +  "type": "boolean"
      +}
  5. Changed2 schema fields changedv0.1.3
    • addedInput schema / properties / package / description
      Added value: +"PyPI distribution name, e.g. 'langchain-core'."
    • addedInput schema / properties / symbols / description
      Added value: +"Up to 100 symbols, each a public dotted path plus the keyword arguments you plan to pass."
  6. First observedv0.1.0

TDQS

A4.5/5.0
Behavior4/5

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

Annotations already establish that this is a read-only, idempotent, non-open-world check. The description adds useful behavioral detail beyond that: results include present/missing/unknown with reasons, rejected kwargs, deprecation notes, and hints.

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

Conciseness5/5

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

The description is compact and front-loaded, starting with the core action and return shape before giving usage and alternatives. Every sentence contributes useful routing or behavioral context.

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

Completeness5/5

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

Given the rich schema, output schema, and annotations, the description supplies the remaining necessary context: what the check returns, when to use it, and which sibling to use instead. Nothing essential for correct invocation is missing.

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?

Schema description coverage is 100%, including detailed SymbolQuery paths and kwargs semantics. The description reinforces that either symbols or code can be supplied, but it does not add much parameter-level meaning beyond the schema.

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

Purpose5/5

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

The description uses a specific verb and resource: batch-check symbols and kwargs against a specific package version. It also distinguishes itself from sibling tools by naming symbol_history and explain_error for adjacent use cases.

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

Usage Guidelines5/5

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

It explicitly says to use this tool to preflight code against the installed version, either by passing symbols or the code itself. It also names the alternatives: symbol_history for one symbol across releases and explain_error after an exception.

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