Enterprise Rent-A-Car MCP Connector
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Enterprise Rent-A-Car MCP ConnectorFind an SUV at LAX from June 15 to 20 and show me the total price"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@striderlabs/mcp-enterprise
A Model Context Protocol (MCP) connector for Enterprise Rent-A-Car. This connector enables AI assistants (such as Claude) to search for vehicles, manage reservations, and check Enterprise Plus loyalty account information — all through enterprise.com via headless browser automation.
Overview
This connector uses Playwright to drive a stealth headless Chromium browser against enterprise.com. It exposes 7 MCP tools covering the full car rental workflow:
Search available vehicles by location, dates, and preferences
Get detailed vehicle pricing and protection options
Create, modify, and cancel reservations
Retrieve Enterprise Plus account details
Check Enterprise Plus loyalty points balance and activity
Session cookies are persisted to ~/.mcp-enterprise/session.json so repeat calls avoid re-authenticating.
Related MCP server: mcp-hertz
Prerequisites
Node.js 18 or higher
npm 9 or higher
Internet access to
enterprise.com
Installation
From the package directory
npm install
npx playwright install chromium
npm run buildAs a global CLI
npm install -g @striderlabs/mcp-enterprise
npx playwright install chromiumConfiguration
No API keys are required. The connector uses Enterprise's public-facing website.
Environment Variable | Description |
| Path to a custom Chromium binary |
| Proxy server for outbound requests |
MCP Client Configuration
Add to your Claude Desktop claude_desktop_config.json:
{
"mcpServers": {
"enterprise": {
"command": "node",
"args": ["/path/to/mcp-enterprise/dist/index.js"]
}
}
}Or if installed globally:
{
"mcpServers": {
"enterprise": {
"command": "mcp-enterprise"
}
}
}Available Tools
search_vehicles
Search for available vehicles at Enterprise for specific dates and locations.
{
"pickup_location": "LAX",
"pickup_date": "2025-06-15",
"pickup_time": "10:00",
"dropoff_date": "2025-06-20",
"dropoff_time": "10:00",
"vehicle_class": "SUV",
"driver_age": 30,
"enterprise_plus_number": "EP123456"
}Returns: Array of available vehicles with vehicle_id, make/model, class, pricing, features, and mileage policy.
get_vehicle_details
Get full pricing breakdown and protection options for a vehicle from search results.
{
"vehicle_id": "ENT-ABC12345",
"rate_code": "STANDARD"
}Returns: Vehicle details plus rate_details (base rate, taxes, fees) and protection_options (LDW, PAI, PEC).
create_reservation
Create a new Enterprise reservation.
{
"vehicle_id": "ENT-ABC12345",
"pickup_location_id": "LAX01",
"pickup_datetime": "2025-06-15T10:00:00",
"dropoff_datetime": "2025-06-20T10:00:00",
"driver_first_name": "Jane",
"driver_last_name": "Smith",
"driver_email": "jane@example.com",
"driver_phone": "555-555-1234",
"enterprise_plus_number": "EP123456",
"protection_plan": "partial"
}Returns: Confirmed Reservation with confirmation_number, vehicle, location, dates, driver info, and cost breakdown.
modify_reservation
Modify an existing reservation (dates, locations, or vehicle class).
{
"confirmation_number": "ENT-XYZ789",
"last_name": "Smith",
"new_pickup_datetime": "2025-06-16T10:00:00",
"new_dropoff_datetime": "2025-06-22T10:00:00",
"new_vehicle_class": "Midsize"
}Returns: Updated Reservation with modified details.
cancel_reservation
Cancel an existing reservation. No fee when cancelled before scheduled pickup.
{
"confirmation_number": "ENT-XYZ789",
"last_name": "Smith",
"reason": "Travel plans changed"
}Returns: { success: true, confirmation_number, message, refund_amount }.
get_account
Retrieve Enterprise Plus account information.
{
"enterprise_plus_number": "EP123456",
"pin": "your-pin"
}Returns: Account details including tier (Standard/Silver/Gold/Platinum), points_balance, rentals_ytd, and free_day_certificates.
get_loyalty_points
Check Enterprise Plus points balance, tier progress, and recent activity.
{
"enterprise_plus_number": "EP123456",
"pin": "your-pin"
}Returns: points_balance, tier, points_to_next_tier, expiration_date, and recent_activity array.
Example Usage with Claude
"Find me an SUV at LAX from June 15–20, then book it for Jane Smith."
Claude will:
Call
search_vehicleswith the specified parametersPresent available SUVs with pricing
Call
create_reservationwith the chosen vehicle and driver detailsReturn the confirmation number
"How many Enterprise Plus points do I have? My number is EP123456."
Claude will call get_loyalty_points and report your balance, tier, and recent activity.
Session Management
Cookies are persisted to ~/.mcp-enterprise/session.json after each authenticated request. This means Enterprise Plus sign-in is preserved across calls, avoiding repeated login prompts.
To clear the session:
rm ~/.mcp-enterprise/session.jsonTroubleshooting
Problem | Solution |
| Ensure |
Search returns no results | Check that enterprise.com is reachable; try a major city or airport code |
Login fails | Verify your Enterprise Plus number and PIN; clear session and retry |
Timeout errors | Increase system timeout or check network connectivity |
License
MIT
Available Tools
7 toolscancel_reservationA
Cancel an existing Enterprise reservation. No cancellation fee when cancelled before the scheduled pickup time.
| Name | Required | Description | Default |
|---|---|---|---|
| confirmation_number | Yes | Enterprise reservation confirmation number | |
| last_name | Yes | Driver's last name as on the reservation | |
| reason | No | Optional cancellation reason |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and adds valuable behavioral context beyond the basic action. It discloses the important policy detail about 'No cancellation fee when cancelled before the scheduled pickup time', which is critical for user decision-making. However, it doesn't mention other behavioral aspects like response format, error conditions, or authentication requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each earn their place. The first sentence states the core purpose, and the second adds critical behavioral context about cancellation fees. There's zero wasted language or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, the description does well by including the cancellation fee policy. However, it could be more complete by mentioning what happens after cancellation (confirmation, refund process) or error scenarios. Given the complexity of a cancellation operation, there's room for slightly more context about the outcome.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, the input schema already documents all three parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline expectation but doesn't provide additional semantic context about how parameters interact or special considerations.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Cancel') and target resource ('an existing Enterprise reservation'), distinguishing it from sibling tools like 'modify_reservation' or 'create_reservation'. It provides precise scope by specifying 'Enterprise' reservation type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool (to cancel reservations) and implicitly distinguishes it from modification tools. However, it doesn't explicitly state when NOT to use it or name specific alternatives among siblings like 'modify_reservation' for changes instead of cancellation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create_reservationC
Create a new Enterprise Rent-A-Car reservation. Requires vehicle selection, location details, dates, and driver information.
| Name | Required | Description | Default |
|---|---|---|---|
| vehicle_id | Yes | Vehicle ID from search_vehicles results | |
| pickup_location_id | Yes | Location ID for vehicle pickup | |
| dropoff_location_id | No | Location ID for vehicle return | |
| pickup_datetime | Yes | ISO datetime for pickup, e.g. 2025-06-15T10:00:00 | |
| dropoff_datetime | Yes | ISO datetime for return, e.g. 2025-06-20T10:00:00 | |
| driver_first_name | Yes | ||
| driver_last_name | Yes | ||
| driver_email | Yes | ||
| driver_phone | Yes | ||
| driver_age | No | ||
| discount_code | No | Promotional or contract code | |
| enterprise_plus_number | No | Enterprise Plus member number | |
| protection_plan | No | full (LDW+PAI+PEC), partial (LDW only), none |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states it 'creates' a reservation without disclosing behavioral traits like whether this is a transactional operation, what happens on success/failure, if it requires authentication, or any rate limits. It mentions required inputs but not the operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently communicates the tool's purpose and key requirements. It is front-loaded with the main action and avoids unnecessary elaboration, making it easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex mutation tool with 13 parameters, no annotations, and no output schema, the description is insufficient. It lacks details on behavioral aspects, error handling, return values, and doesn't fully compensate for the schema's incomplete coverage, leaving the agent with significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description lists categories of required inputs (vehicle, location, dates, driver info), which adds some meaning beyond the schema's 62% coverage. However, it doesn't detail specific parameters or their relationships, leaving gaps for the 38% of schema parameters without descriptions (e.g., driver_age, discount_code).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create a new Enterprise Rent-A-Car reservation') and specifies the required components (vehicle selection, location details, dates, driver information). It distinguishes from siblings like 'modify_reservation' and 'cancel_reservation' by focusing on creation, though it doesn't explicitly contrast with them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions 'Requires' to list necessary inputs, but provides no guidance on when to use this tool versus alternatives like 'modify_reservation' or 'search_vehicles'. It lacks explicit context about prerequisites or scenarios where this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_accountC
Retrieve Enterprise Plus account information including tier status, rental history, and free day certificates.
| Name | Required | Description | Default |
|---|---|---|---|
| enterprise_plus_number | Yes | Enterprise Plus member number or registered email address | |
| pin | Yes | Enterprise Plus PIN or account password |
TDQS
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 implies a read-only operation ('Retrieve') but doesn't specify authentication requirements beyond the parameters, potential rate limits, error conditions, or what happens if credentials are invalid. For a tool requiring sensitive credentials, this is a significant gap in safety and operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose and lists included data points without any fluff or redundancy. Every word earns its place, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a credential-based account retrieval tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the return values look like (e.g., structured data format), error handling, or security implications, leaving the agent with insufficient context for reliable invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema fully documents both parameters (enterprise_plus_number and pin) with clear descriptions. The description adds no additional parameter semantics beyond implying these are used for authentication, which is already evident from the schema. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 'Enterprise Plus account information', specifying what data is included (tier status, rental history, free day certificates). It distinguishes from siblings like get_loyalty_points by focusing on comprehensive account info rather than just points, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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_loyalty_points or other account-related operations. It doesn't mention prerequisites, context for usage, or exclusions, leaving the agent to infer based on parameter requirements alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_loyalty_pointsB
Check Enterprise Plus loyalty points balance, tier status, points required for next tier, expiration date, and recent points activity.
| Name | Required | Description | Default |
|---|---|---|---|
| enterprise_plus_number | Yes | Enterprise Plus member number or registered email address | |
| pin | Yes | Enterprise Plus PIN or account password |
TDQS
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 implies a read-only operation ('Check') but doesn't explicitly state if it's safe, requires authentication (beyond the parameters), has rate limits, or returns structured data. The description lacks details on error handling, response format, or any side effects, which is a significant gap for a tool with authentication parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the purpose and lists all retrieved information without unnecessary words. Every element ('balance, tier status, points required for next tier, expiration date, and recent points activity') earns its place by specifying the tool's scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (authentication parameters, no output schema, no annotations), the description is incomplete. It doesn't explain the return values, error cases, or behavioral traits like security requirements, making it inadequate for an agent to fully understand how to invoke and interpret results without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the input schema already documents both parameters ('enterprise_plus_number' and 'pin') with clear descriptions. The description adds no additional meaning beyond what the schema provides, such as format examples or usage context, but it doesn't need to compensate for gaps, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Check') and resource ('Enterprise Plus loyalty points'), listing exactly what information is retrieved: balance, tier status, points for next tier, expiration date, and recent activity. It distinguishes from sibling tools by focusing on loyalty points rather than reservations, accounts, or vehicles.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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_account' or other siblings. It doesn't mention prerequisites, exclusions, or specific contexts where this tool is preferred, leaving the agent to infer usage based on the purpose alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_vehicle_detailsB
Get detailed information, full pricing breakdown, and available protection options for a specific vehicle from search results.
| Name | Required | Description | Default |
|---|---|---|---|
| vehicle_id | Yes | Vehicle ID from search_vehicles results | |
| rate_code | No | Rate code for specific pricing tier |
TDQS
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 states the tool retrieves information (a read operation) but doesn't address critical aspects like whether this requires authentication, rate limits, error conditions, or what happens with invalid inputs. The description is functional but lacks operational context needed for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently communicates the core functionality without unnecessary words. It's appropriately front-loaded with the main purpose, though it could potentially be split for even better clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (detailed vehicle information with pricing and options), lack of annotations, and absence of an output schema, the description is insufficient. It doesn't explain what 'detailed information' includes, how pricing breakdowns are structured, or what format the response takes. For a tool with two parameters and no structured output documentation, more completeness is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so both parameters (vehicle_id, rate_code) are documented in the schema. The description adds minimal value beyond this, mentioning 'specific vehicle' which aligns with vehicle_id and 'pricing breakdown' which hints at rate_code's purpose. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('get detailed information', 'full pricing breakdown', 'available protection options') and identifies the target resource ('specific vehicle from search results'). It distinguishes itself from siblings like 'search_vehicles' by focusing on detailed retrieval rather than searching, though it doesn't explicitly contrast with other siblings like 'get_account'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by specifying 'from search results', suggesting this tool should be used after a search operation. However, it lacks explicit guidance on when to use this versus alternatives like 'get_account' or 'get_loyalty_points', and doesn't mention prerequisites or exclusions beyond the implied vehicle_id requirement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
modify_reservationC
Modify an existing Enterprise reservation — change dates, locations, or vehicle class.
| Name | Required | Description | Default |
|---|---|---|---|
| confirmation_number | Yes | Enterprise reservation confirmation number | |
| last_name | Yes | Driver's last name as on the reservation | |
| new_pickup_datetime | No | New pickup date/time in ISO format | |
| new_dropoff_datetime | No | New dropoff date/time in ISO format | |
| new_pickup_location_id | No | New pickup location ID | |
| new_dropoff_location_id | No | New dropoff location ID | |
| new_vehicle_class | No | New vehicle class preference |
TDQS
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 implies a mutation ('Modify') but doesn't specify whether this requires authentication, has rate limits, is reversible, or what happens to unchanged fields. For a tool that modifies reservations—a potentially sensitive operation—this lack of detail is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. Every word contributes meaning without redundancy, making it easy for an agent to parse quickly. No extraneous information is included.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of modifying reservations (a mutation with 7 parameters) and the absence of both annotations and an output schema, the description is insufficient. It doesn't cover behavioral aspects like error conditions, success responses, or dependencies, leaving the agent with incomplete context for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 7 parameters. The description adds minimal value by hinting at the types of modifications ('dates, locations, or vehicle class'), which aligns with the schema but doesn't provide additional semantics like format examples or constraints. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Modify') and resource ('existing Enterprise reservation'), and specifies what can be modified ('change dates, locations, or vehicle class'). It distinguishes from siblings like 'cancel_reservation' and 'create_reservation' by focusing on updates rather than creation or cancellation. However, it doesn't explicitly contrast with all siblings, keeping it at 4 rather than 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 'cancel_reservation' or 'create_reservation'. It doesn't mention prerequisites (e.g., needing an existing reservation) or constraints (e.g., modification policies). Without such context, the agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_vehiclesA
Search for available vehicles at Enterprise Rent-A-Car for specific dates, locations, and preferences. Returns a list of available cars with pricing and features.
| Name | Required | Description | Default |
|---|---|---|---|
| pickup_location | Yes | City name, airport code (e.g. LAX), or street address | |
| dropoff_location | No | Return location if different from pickup | |
| pickup_date | Yes | ISO date YYYY-MM-DD | |
| pickup_time | Yes | HH:MM format (24-hour), e.g. 09:00 | |
| dropoff_date | Yes | ISO date YYYY-MM-DD | |
| dropoff_time | Yes | HH:MM format (24-hour), e.g. 17:00 | |
| vehicle_class | No | Optional vehicle class filter | |
| driver_age | No | Driver age in years, default 25 | |
| discount_code | No | Promotional or contract discount code | |
| enterprise_plus_number | No | Enterprise Plus member number for member rates |
TDQS
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 that the tool 'Returns a list of available cars with pricing and features,' which adds some context on output. However, it fails to disclose critical behavioral traits such as whether this is a read-only operation, potential rate limits, authentication needs, or how results are filtered or sorted, leaving significant gaps for a tool with 10 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences that are front-loaded: the first sentence states the purpose and scope, and the second explains the return value. There is zero waste, and every sentence earns its place by adding essential information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of 10 parameters and no output schema, the description is partially complete. It covers the basic purpose and return format but lacks details on behavioral aspects like error handling, pagination, or data freshness. Without annotations, it should provide more context on operational constraints to fully guide an AI agent, resulting in a moderate score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds minimal meaning beyond the input schema, which has 100% coverage with detailed parameter descriptions. It mentions 'dates, locations, and preferences,' aligning with parameters like pickup/dropoff and vehicle_class, but does not provide additional syntax, format details, or usage examples. With high schema coverage, the baseline score of 3 is appropriate as the schema does most of the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Search for available vehicles'), the resource ('at Enterprise Rent-A-Car'), and the scope ('for specific dates, locations, and preferences'). It distinguishes this from siblings like 'create_reservation' or 'get_vehicle_details' by focusing on availability search rather than booking or detailed vehicle information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through 'Search for available vehicles... for specific dates, locations, and preferences,' suggesting when to use it. However, it lacks explicit guidance on when to choose this tool over alternatives like 'get_vehicle_details' or 'create_reservation,' and does not mention prerequisites or exclusions, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool has a clearly distinct purpose with no overlap: cancel_reservation, create_reservation, modify_reservation handle the reservation lifecycle; get_account and get_loyalty_points focus on account and loyalty data; search_vehicles and get_vehicle_details cover vehicle discovery and details. The descriptions reinforce these boundaries, making misselection unlikely.
All tools follow a consistent verb_noun pattern with clear, descriptive names (e.g., cancel_reservation, get_account, search_vehicles). There are no deviations in style or convention, making the set predictable and easy to understand at a glance.
With 7 tools, the count is well-scoped for a car rental domain, covering core operations like reservation management (create, modify, cancel), vehicle search and details, and account/loyalty features. Each tool earns its place without redundancy or bloat.
The tool set provides complete coverage for the car rental domain: full CRUD for reservations (create, modify, cancel), vehicle discovery (search_vehicles and get_vehicle_details), and account management (get_account and get_loyalty_points). There are no obvious gaps that would hinder agent workflows.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Stealth web automation for AI agents. Login, signup, navigate, screenshot.
Stealth web automation for AI agents. Login, signup, navigate, screenshot.
AI-powered browser automation — navigate, click, fill forms, and extract data from any website.
AI-powered web automation. Navigate websites using AI agents for one page or a thousand
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI agents to automate Delta Air Lines tasks such as searching flights, managing bookings, and checking SkyMiles balances through Playwright-based browser automation. It supports the complete travel workflow including seat selection, check-in, and digital boarding pass retrieval.17534MIT
- AlicenseAqualityDmaintenanceEnables AI assistants to interact with the Hertz car rental service through headless browser automation. It supports searching for vehicles, managing reservations, checking loyalty status, and retrieving rental policies directly from the Hertz website.1018MIT
- AlicenseAqualityDmaintenanceEnables users to automate Zipcar car sharing tasks such as searching for available vehicles, managing reservations, and ending trips using stealth browser automation. It provides a standardized interface for interacting with Zipcar's services through natural language and the Model Context Protocol.616MIT
- AlicenseAqualityBmaintenanceEnables AI agents to search hotels, check availability, manage reservations, and book rooms on Booking.com via browser automation.215335MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/markswendsen-code/mcp-enterprise'
If you have feedback or need assistance with the MCP directory API, please join our Discord server