Congress[.]gov MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation5/5
Each tool targets a distinct resource type within the Congress.gov domain, such as amendments, bills, committees, members, etc. The descriptions clearly differentiate the data each tool retrieves, with no overlap in purpose or functionality.
Naming Consistency5/5
All tools follow a consistent 'get_' prefix with snake_case naming, clearly indicating retrieval operations. The pattern is uniform across all 21 tools, making them predictable and easy to understand.
Tool Count3/5
With 21 tools, the count is on the higher side for a single server, but it aligns with the comprehensive scope of the Congress.gov API covering many legislative entities. It feels slightly heavy but is reasonable given the domain complexity.
Completeness4/5
The tool set provides broad coverage of legislative data types, including bills, amendments, committees, members, votes, and more. Minor gaps may exist, such as lack of update or delete operations, but this is typical for a read-only API wrapper and agents can work effectively with the provided retrieval tools.
Average 3.2/5 across 21 of 21 tools scored. Lowest: 1/5.
See the Tool Scores section below for per-tool breakdowns.
- 0 of 2 community issues answered or closed in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Tool has no description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness1/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Tool has no description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Tool has no description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Tool has no description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose1/5
Does the description clearly state what the tool does and how it differs from similar tools?
Tool has no description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Tool has no description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. While it mentions the API source and return format ('dict: House vote data'), it lacks critical behavioral information: whether this is a read-only operation, authentication requirements, rate limits, error handling, or pagination behavior beyond offset/limit parameters. The external documentation link doesn't compensate for missing behavioral details in the description itself.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably structured with clear sections (purpose, args, returns) but includes unnecessary elements. The external documentation link in the first sentence doesn't help an AI agent select/invoke the tool and could be omitted. The parameter explanations are helpful but make the description longer than necessary for optimal conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 7 parameters with 0% schema coverage and no output schema, the description provides good parameter documentation but lacks important contextual information. It doesn't explain the return structure beyond 'dict: House vote data,' doesn't mention error conditions or authentication needs, and provides no guidance on tool selection among siblings. For a data retrieval tool with many parameters, this leaves significant gaps in understanding how to effectively use it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage (titles only, no descriptions), the description provides substantial parameter semantics beyond the schema. It explains each parameter's purpose, provides examples (e.g., '118 for 118th Congress'), format requirements ('YYYY-MM-DDTHH:MM:SSZ format'), and constraints ('max 250, default 20'). This significantly compensates for the schema's lack of descriptions, though it doesn't cover all possible edge cases.
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: 'Retrieve House vote information from the Congress.gov API.' It specifies the resource (House vote information) and the source (Congress.gov API). However, it doesn't explicitly differentiate this from sibling tools like get_bills or get_members, which would be needed for a score of 5.
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. With many sibling tools available (e.g., get_bills, get_members, get_committees), there's no indication of when House vote retrieval is appropriate versus other congressional data tools. The link to external documentation doesn't substitute for explicit usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 the API endpoint and return format ('dict: Committee meeting data'), but lacks critical behavioral details: whether this is a read-only operation, rate limits, authentication requirements, error handling, pagination behavior beyond offset/limit, or what specific data fields are included. The external documentation link is helpful but doesn't replace direct disclosure in the description.
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 with clear sections (purpose, args, returns) and uses bullet points effectively. Every sentence adds value: the first states the purpose, the second provides documentation reference, and the parameter explanations are essential. While slightly verbose due to detailed param documentation, this is justified given the 0% schema coverage. It could be more front-loaded by moving the returns statement earlier.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 6 parameters with 0% schema coverage and no output schema, the description does a good job documenting parameters but has significant gaps. It lacks behavioral context (no annotations), doesn't explain the return structure beyond 'dict', and provides no usage guidance. For a data retrieval tool with multiple filtering parameters, the description is minimally adequate but leaves the agent to guess about important aspects like error cases, data format, and practical constraints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides excellent parameter documentation with clear explanations, examples, and constraints for all 6 parameters, despite 0% schema description coverage. It adds substantial value beyond the bare schema by explaining what each parameter means (e.g., 'Congress number (e.g., 118 for 118th Congress)'), format requirements ('YYYY-MM-DDTHH:MM:SSZ format'), and practical constraints ('max 250, default 20'). 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 action ('Retrieve committee meeting information') and resource ('from the Congress.gov API'), providing a specific verb+resource combination. It distinguishes itself from siblings like 'get_committees' by focusing on meetings rather than committee entities. However, it doesn't explicitly differentiate from other meeting-related tools that might exist in the broader context.
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. While it mentions the API endpoint documentation, it doesn't specify use cases, prerequisites, or comparisons with sibling tools like 'get_hearings' or 'get_committees'. The agent must infer usage from the tool name and parameter set alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions retrieving data and includes a link to external documentation, but doesn't describe key behaviors like whether this is a read-only operation, error handling, rate limits, authentication needs, or response structure. The link adds some context but doesn't compensate for missing behavioral details in the description itself.
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 with clear sections (purpose, args, returns) and uses bullet points for parameters. It's appropriately sized, though the external link might be considered extraneous. Every sentence adds value, and the information is front-loaded with the core purpose stated first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/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 (5 parameters, no annotations, no output schema), the description is partially complete. It covers parameters well but lacks behavioral context, usage guidelines, and output details. The external link provides a fallback, but the description itself doesn't fully address the tool's operational needs, especially for an API call with multiple parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds substantial meaning beyond the input schema, which has 0% description coverage. It explains each parameter's purpose with examples (e.g., 'hsag' for House Agriculture), default values, formats (YYYY-MM-DDTHH:MM:SSZ), and constraints (max 250 for limit). This effectively compensates for the schema's lack of documentation, though it could benefit from more context on parameter interactions.
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 as 'Retrieve committee information from the Congress.gov API,' which includes a specific verb ('Retrieve') and resource ('committee information'). It distinguishes from siblings by focusing on committees rather than bills, members, votes, etc., though it doesn't explicitly contrast with similar tools like 'get_committee_meetings' or 'get_committee_reports.'
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 mentions a link to full documentation but doesn't specify use cases, prerequisites, or exclusions. With sibling tools like 'get_committee_meetings' and 'get_committee_reports' available, this lack of differentiation is a significant gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions the API endpoint and provides a link to documentation, but doesn't disclose key behavioral traits: whether this is a read-only operation, rate limits, authentication requirements, error handling, or what specific data fields are returned. The description is minimal beyond basic functionality.
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 well-structured with clear sections (Args, Returns). The first sentence states the purpose, followed by documentation link and parameter details. Every sentence adds value, though the documentation link could be more integrated rather than standalone.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 3-parameter tool with no annotations and no output schema, the description provides basic parameter semantics and return type indication ('dict: Congress data'). However, it lacks details about the structure of returned data, error cases, authentication, or how it differs from sibling tools, leaving significant gaps for an agent to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates well by explaining all three parameters: 'congress' (specific number or None for all), 'offset' (starting record), and 'limit' (max records with constraints). It provides practical examples and constraints beyond what the bare schema shows, though it doesn't explain parameter interactions or validation rules.
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: 'Retrieve congress information from the Congress.gov API.' It specifies the verb ('retrieve') and resource ('congress information'), though it doesn't explicitly differentiate from siblings like 'get_members' or 'get_committees' which retrieve different types of congressional data.
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. With many sibling tools retrieving different congressional data types (e.g., bills, members, committees), there's no indication of what 'congress information' specifically includes or when to choose this over other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 the API endpoint documentation link and some parameter defaults/constraints (limit max 250, default 20), but doesn't cover important behavioral aspects like rate limits, authentication requirements, error handling, pagination behavior, or what happens when parameters are omitted. For a tool with 6 parameters and no annotations, this leaves significant gaps in understanding how the tool behaves.
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 with clear sections (purpose, args, returns) and efficiently conveys necessary information. The API documentation link is appropriately placed. While slightly verbose due to listing all parameters, each sentence serves a clear purpose and the structure helps the agent parse the information effectively.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (6 parameters, no annotations, no output schema), the description does a decent job but has notable gaps. It thoroughly documents parameters and states the return type, but lacks behavioral context (rate limits, auth, error handling) and doesn't explain the relationship to sibling tools. For a read-only API tool, this is minimally adequate but could be more complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides excellent parameter documentation despite 0% schema description coverage. It clearly explains all 6 parameters with their purposes, defaults, constraints (limit max 250), and format requirements (from_datetime/to_datetime format). This fully compensates for the lack of schema descriptions and gives the agent meaningful guidance on how to use each parameter effectively.
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: 'Retrieve daily congressional record information from the Congress.gov API.' It specifies both the action ('retrieve') and the resource ('daily congressional record information'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate this tool from its sibling 'get_congressional_record' or 'get_bound_congressional_record', which appear to be related tools for congressional records.
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. With multiple sibling tools related to congressional records (get_congressional_record, get_bound_congressional_record), there's no indication of how this 'daily' version differs or when it should be preferred. The description only states what the tool does, not when to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the API source and provides a documentation link, but doesn't describe authentication requirements, rate limits, error behavior, or what specific data fields are returned. 'Retrieve' implies a read operation, but there's no explicit safety declaration. The description adds minimal behavioral context beyond the basic operation.
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 with clear sections (Args, Returns) and uses bullet points effectively for parameter details. It's appropriately sized for a 7-parameter tool. The external documentation link is useful but doesn't disrupt the flow. Minor improvement could be front-loading more critical information before the parameter details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 7-parameter retrieval tool with no annotations and no output schema, the description provides good parameter documentation but lacks important context. It doesn't explain the return data structure, pagination behavior (beyond offset/limit parameters), error conditions, or authentication requirements. The external documentation link helps but doesn't make the description itself complete for agent usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description provides excellent parameter documentation that fully compensates. It explains all 7 parameters with clear examples (e.g., '118 for 118th Congress'), enumerated values for communication_type, format specifications ('YYYY-MM-DDTHH:MM:SSZ'), and default values. This adds substantial meaning beyond what the bare schema provides.
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 'Retrieve House communication information from the Congress.gov API' which specifies both the action (retrieve) and resource (House communication information). It distinguishes from siblings like 'get_senate_communication' by specifying 'House' communication. However, it doesn't explicitly differentiate from other data retrieval tools like 'get_bills' or 'get_committees' beyond the resource type.
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. With sibling tools like 'get_senate_communication' and 'get_bills' available, there's no indication of when House communications specifically are needed versus other legislative data sources. The external documentation link is helpful but doesn't provide in-description usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the API endpoint and return format ('dict: House requirement data'), but lacks critical behavioral details: whether this is a read-only operation, what authentication might be required, rate limits, error handling, or what specific data structure is returned. The external documentation link partially compensates but isn't self-contained.
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?
Well-structured with purpose statement, documentation link, parameter details, and return format. The Args/Returns sections are clearly organized. Slightly verbose with the full URL, but each sentence serves a purpose. Could be more front-loaded by moving the return format closer to the purpose statement.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 6-parameter tool with no annotations and no output schema, the description does reasonably well on parameters but lacks behavioral context. The external documentation link helps but creates dependency. Without understanding what 'House requirement' data contains or how it differs from other congressional data, an agent might struggle to use this appropriately versus siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description provides excellent parameter documentation that fully compensates. Each of the 6 parameters gets clear explanations with examples (e.g., '118 for 118th Congress'), format specifications ('YYYY-MM-DDTHH:MM:SSZ format'), and constraints ('max 250, default 20'). This adds substantial value beyond the bare schema.
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 verb 'Retrieve' and resource 'House requirement information from the Congress.gov API', making the purpose unambiguous. It doesn't explicitly differentiate from siblings like get_bills or get_committees, but the specificity of 'House requirement' provides inherent distinction. The link to external documentation adds precision but doesn't fully substitute for sibling differentiation.
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?
No guidance is provided about when to use this tool versus alternatives like get_bills or get_house_votes. The description mentions the API endpoint but doesn't explain what 'House requirement' means or when this specific data type would be needed versus other congressional data types available in sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral context. It mentions the API endpoint documentation link and basic return format ('dict: Senate communication data'), but doesn't disclose important traits like whether this is a read-only operation, rate limits, authentication requirements, error handling, or what specific data fields are returned. The description is functional but lacks operational transparency.
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 with clear sections (purpose, Args, Returns) and uses bullet points for parameter details. While somewhat lengthy due to 7 parameters, every sentence adds value - the API documentation link is useful, parameter explanations are necessary given poor schema coverage, and the return statement is minimal but adequate.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 7-parameter tool with no annotations and no output schema, the description is moderately complete. It thoroughly documents parameters but lacks behavioral context (rate limits, auth, error handling) and only vaguely describes returns ('dict: Senate communication data'). Given the complexity and absence of structured metadata, more operational details would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage for 7 parameters, the description compensates well by providing clear explanations for all parameters, including examples (e.g., '118 for 118th Congress'), enumerated values for communication_type, format specifications ('YYYY-MM-DDTHH:MM:SSZ format'), and default values. This adds substantial meaning beyond what the bare schema provides.
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 verb 'Retrieve' and resource 'Senate communication information from the Congress.gov API', making the purpose explicit. It distinguishes this tool from siblings like 'get_house_communication' by specifying Senate communications, but doesn't explain how it differs from other data retrieval tools in the same API family beyond the resource type.
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. While it's clearly for Senate communications (versus House communications), there's no mention of when to use this versus other congressional data tools like get_bills or get_committee_reports, nor any context about typical use cases or prerequisites for Senate communication data.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the API endpoint documentation link and return format ('dict: Amendment data'), but lacks critical behavioral details like rate limits, authentication requirements, error handling, pagination behavior beyond offset/limit, or what happens when parameters are omitted.
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 with clear sections (purpose, args, returns) and uses bullet points for parameter details. While the external documentation link adds some length, every sentence provides value. It could be slightly more front-loaded with a clearer summary before the parameter details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 7-parameter tool with no annotations and no output schema, the description does a good job with parameter documentation but has significant gaps. It lacks behavioral context (rate limits, auth), doesn't explain the return structure beyond 'dict', and provides no sibling differentiation. The parameter documentation compensates somewhat, but overall completeness is only adequate.
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?
With 0% schema description coverage and 7 parameters, the description provides excellent parameter semantics beyond the bare schema. It explains each parameter's purpose, provides examples (e.g., '118 for 118th Congress'), enumerates amendment_type values with descriptions, clarifies dependencies ('requires congress and amendment_type'), and specifies format requirements ('YYYY-MM-DDTHH:MM:SSZ format').
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 verb ('Retrieve') and resource ('amendments from the Congress.gov API'), making the purpose unambiguous. It doesn't explicitly differentiate from sibling tools like 'get_bills' or 'get_members', but the specific resource focus provides implicit differentiation.
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 like 'get_bills' or other legislative data tools. It mentions parameter dependencies ('requires congress and amendment_type') but offers no contextual usage advice for the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool retrieves data and links to external docs, but fails to describe key traits like rate limits, authentication needs, error handling, or pagination behavior beyond basic parameter defaults. This is inadequate for a tool with 8 parameters and no structured safety hints.
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 with a clear purpose statement, organized parameter list, and return note, but includes a redundant external documentation link that could be trimmed. Most sentences earn their place by providing essential information, though slight verbosity in the link reduces efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (8 parameters, no annotations, no output schema), the description covers parameters thoroughly but lacks behavioral context and output details. It is minimally viable for basic use but incomplete for full agent understanding, as it omits guidance on errors, data structure, or integration with siblings.
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?
With 0% schema description coverage, the description compensates fully by detailing all 8 parameters, including examples (e.g., congress number 118), enumerated options for bill_type, defaults, formats (e.g., YYYY-MM-DDTHH:MM:SSZ), and constraints (e.g., limit max 250). This adds significant meaning beyond the bare schema, making parameter usage clear.
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 starts with 'Retrieve a list of bills,' which clearly states the verb ('retrieve') and resource ('bills'), making the purpose explicit. However, it does not differentiate this tool from its siblings (e.g., get_amendments, get_committees), which also retrieve legislative data, so it lacks sibling distinction, preventing a score of 5.
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, such as other sibling tools like get_amendments or get_members. It mentions a link to external documentation but does not offer explicit usage context, prerequisites, or exclusions, leaving the agent with minimal direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 the API source and a documentation link, which adds some context, but doesn't describe key behaviors like authentication requirements, rate limits, error handling, or pagination details (beyond offset/limit parameters). The description doesn't contradict annotations (none exist), but it lacks sufficient behavioral details for a mutation-free read operation.
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 appropriately sized. It starts with the core purpose, includes a documentation link, lists parameters with helpful details (defaults, ranges, formats), and specifies the return type. Every sentence adds value, though the documentation link could be more integrated into usage guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, no annotations, no output schema), the description is moderately complete. It covers parameters thoroughly but lacks output details (only mentions 'dict' return), behavioral context (e.g., rate limits), and differentiation from siblings. For a read-only API tool, this is adequate but has clear gaps in guiding effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant value beyond the input schema, which has 0% description coverage. It explains all 7 parameters with clear semantics: year, month, day, offset (starting record), limit (max 250, default 20), and datetime ranges in specific formats. This compensates well for the schema's lack of descriptions, though it doesn't clarify parameter interactions or dependencies.
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: 'Retrieve bound congressional record information from the Congress.gov API.' It specifies the verb ('retrieve'), resource ('bound congressional record information'), and source ('Congress.gov API'), which is specific and actionable. However, it doesn't explicitly differentiate this tool from its sibling 'get_congressional_record' or 'get_daily_congressional_record', which appears to be a related tool for congressional records.
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 mentions a link to full documentation but doesn't specify use cases, prerequisites, or comparisons with sibling tools like 'get_congressional_record' or 'get_daily_congressional_record'. This leaves the agent without context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions the API endpoint and parameter defaults, it doesn't describe important behavioral aspects: whether this is a read-only operation, what authentication might be required, rate limits, error conditions, or what the returned data structure looks like. The link to external documentation is helpful but doesn't substitute for self-contained behavioral description.
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 with clear sections (purpose, args, returns) and uses bullet points for parameter details. Every sentence earns its place, though the external documentation link could be more integrated. The description is appropriately sized for a 7-parameter tool without unnecessary verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, no annotations, no output schema), the description is moderately complete. It excels at parameter documentation but lacks behavioral context and output details. The absence of annotations means the description should cover more about the tool's operational characteristics, but it doesn't fully address this gap despite the parameter coverage.
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 excellent parameter semantics despite 0% schema description coverage. It clearly explains all 7 parameters with examples (e.g., '118 for 118th Congress'), enumerated values for print_type (hprt, sprt, jprt), format specifications (YYYY-MM-DDTHH:MM:SSZ), and practical constraints (max 250 records). This fully compensates for the lack of schema 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: 'Retrieve committee print information from the Congress.gov API.' It specifies the resource (committee prints) and verb (retrieve). However, it doesn't explicitly differentiate this tool from its siblings like get_committee_reports or get_hearings, which also retrieve congressional documents.
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 mentions a link to full documentation but gives no explicit context about when this specific tool is appropriate compared to sibling tools like get_committee_reports or get_hearings. There's no mention of prerequisites, constraints, or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions the API endpoint and provides parameter details, it doesn't describe important behavioral aspects like authentication requirements, rate limits, error handling, pagination behavior (beyond offset/limit parameters), or what happens when parameters are omitted. The link to external documentation partially compensates but doesn't provide immediate transparency.
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 with clear sections (purpose, Args, Returns) and uses bullet points for enumerated values. It's appropriately sized for a 7-parameter tool, though the external documentation link could be considered extraneous. Every sentence earns its place by providing necessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, no annotations, no output schema), the description is moderately complete. It thoroughly documents parameters but lacks behavioral context and output details. The absence of an output schema means the description should ideally explain return values beyond 'Committee report data from Congress.gov API,' but it doesn't provide structure or examples of the returned data.
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?
With 0% schema description coverage (titles only, no descriptions), the description provides excellent parameter semantics compensation. It clearly explains all 7 parameters with examples (e.g., '118 for 118th Congress'), enumerated values for report_type, format specifications (YYYY-MM-DDTHH:MM:SSZ), defaults, and constraints (max 250). This adds substantial meaning beyond what the bare schema provides.
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 as 'Retrieve committee report information from the Congress.gov API,' which is a specific verb+resource combination. However, it doesn't explicitly differentiate this tool from its many siblings (like get_committee_meetings, get_committee_prints, get_committees), which all retrieve different types of congressional data from the same API.
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. With 20 sibling tools available (including get_committee_meetings and get_committee_prints for similar committee-related data), there's no indication of what distinguishes committee reports from other committee outputs or when this specific retrieval is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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. While it mentions the API endpoint documentation link and describes some parameter behaviors (defaults, max values), it doesn't disclose important behavioral traits like rate limits, authentication requirements, error handling, pagination behavior beyond offset/limit, or what happens when multiple filters conflict. The description is functional but lacks comprehensive behavioral context.
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 with clear sections (purpose, args, returns) and efficiently communicates essential information. While the external documentation link adds value, the description itself is appropriately sized and front-loaded with the core purpose. Every sentence serves a clear function in explaining the tool's usage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (6 parameters, no annotations, no output schema), the description provides solid parameter documentation but lacks complete behavioral context. The return value description ('dict: Member data from Congress.gov API') is minimal without explaining the structure or content of the returned data. For a tool with multiple filtering parameters and no output schema, more detail about the response format would be helpful.
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 excellent parameter semantics that fully compensate for the 0% schema description coverage. It clearly explains each of the 6 parameters with specific examples ('A000374'), format requirements ('YYYY-MM-DDTHH:MM:SSZ'), constraints ('max 250'), defaults, and filtering logic. This goes well beyond what the bare schema provides and gives the agent practical guidance on how to use each parameter effectively.
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 verb ('Retrieve') and resource ('member information from the Congress.gov API'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from its many siblings (like get_committees or get_bills), which all appear to retrieve different types of congressional data from the same API.
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. With 19 sibling tools that all retrieve different congressional data types, there's no indication of what distinguishes member information retrieval from other data types or when an agent should choose this specific tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 retrieval and includes parameter details, but lacks critical behavioral traits such as whether this is a read-only operation, potential rate limits, authentication needs, error handling, or pagination behavior beyond offset/limit. The link to external documentation is insufficient for direct agent use.
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 appropriately sized, with a clear purpose statement, documentation link, parameter explanations, and return value note. Every sentence adds value, though the external link might distract slightly from self-contained clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (6 parameters, no annotations, no output schema), the description is partially complete. It excels in parameter semantics but lacks behavioral context (e.g., safety, limits) and output details beyond 'dict: Nomination data'. This leaves gaps for an agent to invoke it confidently without external resources.
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 adds significant value beyond the input schema, which has 0% description coverage. It explains all six parameters with clear semantics: congress as 'Congress number (e.g., 118)', nomination_number as 'Specific nomination number', offset as 'Starting record', limit with 'max 250', and datetime formats. 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 action ('Retrieve nomination information') and resource ('from the Congress.gov API'), making the purpose understandable. However, it doesn't explicitly differentiate this tool from its siblings (like get_bills or get_members) beyond the 'nomination' focus, which prevents a perfect score.
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 mentions a documentation link but doesn't specify use cases, prerequisites, or comparisons with sibling tools (e.g., get_bills for legislation vs. get_nomination for nominations), leaving the agent without contextual direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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. It discloses that it retrieves data from an external API and mentions default values and limits (max 250 records), which adds useful context. However, it doesn't cover important behavioral aspects like error handling, authentication requirements, rate limits, pagination behavior beyond offset/limit, or what happens when parameters are null. The link to documentation partially compensates but isn't self-contained.
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 with a clear purpose statement, documentation link, parameter details in a formatted Args section, and return value description. It's appropriately sized for a 6-parameter tool. The documentation link is useful but could be more integrated. Every sentence earns its place, though the 'Returns' line is somewhat vague.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 6 parameters, no annotations, and no output schema, the description is moderately complete. It covers all parameters and mentions the API source, but lacks details about the return structure (beyond 'dict'), error conditions, authentication, or rate limiting. For a read-only API tool with multiple filters, more behavioral context would be helpful, though the parameter documentation is solid.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It provides clear explanations for all 6 parameters: congress number, treaty number, pagination controls (offset/limit), and datetime filters with format examples. This adds significant meaning beyond the bare schema. However, it doesn't explain parameter interactions (e.g., how treaty_number affects other filters) or what 'null' values mean for optional parameters.
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: 'Retrieve treaty information from the Congress.gov API.' It specifies the verb ('Retrieve') and resource ('treaty information'), and distinguishes it from siblings by focusing on treaties rather than bills, amendments, etc. However, it doesn't explicitly differentiate from hypothetical treaty-related siblings beyond naming the endpoint.
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 mentions the API endpoint documentation but doesn't explain when treaty retrieval is appropriate compared to other data types (bills, members, etc.) available in the sibling tools. There's no mention of prerequisites, typical use cases, or constraints beyond parameter defaults.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 the API source and provides some parameter details (like limit max of 250), but doesn't cover important aspects like rate limits, authentication requirements, error handling, or what specific data fields are returned in the 'congressional record data'.
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 with clear sections (purpose, args, returns) and uses bullet points for parameter explanations. It's appropriately sized for a 7-parameter tool, though the documentation link could be more integrated rather than standalone.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 7 parameters, 0% schema coverage, no annotations, and no output schema, the description does a good job with parameters but leaves gaps in behavioral context. It explains what the tool does and documents parameters well, but doesn't provide enough information about the return structure, error conditions, or how this differs 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?
With 0% schema description coverage and 7 parameters, the description provides excellent parameter semantics compensation. It explains each parameter clearly, including the meaning of page_prefix values (h, s, e, d), default values for offset and limit, format requirements for timestamps, and the maximum limit constraint.
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 verb 'retrieve' and the resource 'congressional record information from the Congress.gov API', making the purpose understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'get_daily_congressional_record' or 'get_bound_congressional_record', which appear to be related alternatives.
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 like 'get_daily_congressional_record' or 'get_bound_congressional_record'. It mentions a documentation link but doesn't explain the specific use case or context for this particular endpoint compared to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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. While it mentions the API endpoint and provides parameter details, it doesn't describe important behavioral aspects like rate limits, authentication requirements, error handling, pagination behavior (beyond offset/limit parameters), or what happens when parameters are omitted. For a 7-parameter tool with zero annotation coverage, this is insufficient.
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 with clear sections (purpose, documentation link, args, returns) and uses bullet points effectively. While it could be slightly more concise by integrating some parameter details, every sentence serves a purpose and the information is front-loaded with the core functionality stated first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 7-parameter tool with no annotations and no output schema, the description provides good parameter documentation but lacks behavioral context. The return value description ('Hearing data from Congress.gov API') is vague without an output schema. Given the complexity and absence of structured metadata, the description should do more to explain behavior, error cases, and result format.
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?
With 0% schema description coverage, the description fully compensates by providing clear documentation for all 7 parameters. Each parameter gets specific details: congress includes an example (118), chamber lists valid values (house, senate), hearing_number is explained, offset and limit have defaults, and datetime parameters specify exact format requirements. This adds substantial value beyond the bare 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 clearly states the specific action ('Retrieve hearing information') and resource ('from the Congress.gov API'), distinguishing it from sibling tools like get_bills or get_committees. It provides a precise verb+resource combination that leaves no ambiguity about what this tool does.
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 like get_committee_meetings or other sibling tools. While it mentions the API endpoint documentation, it doesn't offer any contextual advice about appropriate use cases, prerequisites, or comparisons with related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 the API endpoint and provides parameter details, but doesn't describe important behavioral aspects like rate limits, authentication requirements, error conditions, or pagination behavior beyond the offset/limit parameters. The description doesn't contradict any annotations (since none exist), but leaves significant behavioral questions unanswered.
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 with clear sections (Args, Returns) and uses bullet points for the bill_type parameter. It's appropriately sized for a 7-parameter tool. However, the first sentence could be more front-loaded with key information, and the external documentation link could be better integrated rather than appearing as the second sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 7-parameter tool with no annotations and no output schema, the description provides good parameter documentation but lacks important contextual information. It doesn't explain what 'summary data' contains, how results are structured, or provide examples of return values. The external documentation link helps, but the description itself should provide more complete guidance for agent usage given the tool's complexity.
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?
Given 0% schema description coverage, the description provides excellent parameter semantics that fully compensate. It explains all 7 parameters with clear explanations, examples (e.g., '118 for 118th Congress'), enumerated values for bill_type, format specifications (YYYY-MM-DDTHH:MM:SSZ), and default values. This adds substantial meaning beyond what the bare schema provides.
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 action ('Retrieve') and resource ('bill summaries from the Congress.gov API'), making the purpose immediately understandable. It distinguishes itself from siblings by focusing specifically on summaries rather than bills, amendments, or other legislative documents. However, it doesn't explicitly contrast with similar tools like 'get_bills' in terms of what summaries contain versus full bill text.
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. With many sibling tools available (like get_bills, get_amendments, get_committee_reports), there's no indication of when summaries are appropriate versus full documents or other legislative data. The only contextual guidance is the link to external documentation, which doesn't help the agent make tool selection decisions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 the API source and default/limit values for parameters, but lacks critical behavioral details such as authentication requirements, rate limits, error handling, or whether it's a read-only operation. This is a significant gap for an API 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 appropriately sized and front-loaded with the core purpose, followed by a documentation link and structured parameter details. Every sentence earns its place, though the link could be integrated more seamlessly. It avoids unnecessary verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of an API tool with 5 parameters, no annotations, and no output schema, the description is partially complete. It excels in parameter semantics but lacks behavioral context (e.g., auth, errors) and output details, leaving gaps for effective agent use.
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?
Schema description coverage is 0%, so the description must compensate fully. It provides detailed semantics for all 5 parameters, including purpose (e.g., 'product_code: Specific product code for CRS report'), defaults, formats (e.g., timestamp format), and constraints (e.g., 'max 250'). This adds substantial value beyond the bare 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 clearly states the specific action ('Retrieve CRS report information') and resource ('from the Congress.gov API'), distinguishing it from sibling tools like get_bills or get_members. It precisely identifies what the tool does without being vague or tautological.
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 implies usage context by specifying the data source (Congress.gov API) and linking to full documentation, but it does not explicitly state when to use this tool versus alternatives like get_committee_reports or get_hearings. No exclusions or clear alternatives are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![congress_gov_mcp MCP server](https://glama.ai/mcp/servers/AshwinSundar/congress_gov_mcp/badges/card.svg)](https://glama.ai/mcp/servers/AshwinSundar/congress_gov_mcp)

Score Badge

Copy to your README.md:

[![congress_gov_mcp MCP server](https://glama.ai/mcp/servers/AshwinSundar/congress_gov_mcp/badges/score.svg)](https://glama.ai/mcp/servers/AshwinSundar/congress_gov_mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/AshwinSundar/congress_gov_mcp'

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