Google Ads MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes, such as execute_gaql_query for querying, get_performance for metrics, and manage_auth for authentication. However, there is some overlap between end_session, refresh_access_token, and set_session_credentials, all related to session management, which could cause minor confusion for an agent.
Naming Consistency4/5
The tools generally follow a consistent verb_noun pattern, like execute_gaql_query and get_performance, with clear actions. A minor deviation is gaql_help, which uses a noun_verb format, but overall the naming is predictable and readable across the set.
Tool Count5/5
With 9 tools, the count is well-scoped for a Google Ads API server, covering key operations like querying, performance analysis, resource listing, and authentication. Each tool serves a specific function without redundancy, making the set efficient and manageable.
Completeness4/5
The toolset provides strong coverage for core Google Ads workflows, including data querying, performance retrieval, and authentication management. A minor gap is the lack of tools for modifying resources, such as creating or updating campaigns, but agents can still perform essential read and analysis tasks effectively.
Average 3/5 across 9 of 9 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues 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 status not available
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

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 states the tool retrieves status but doesn't specify what information is returned, whether it's read-only, if it requires authentication, or any rate limits. The mention of 'multi-tenant mode' is unclear and adds minimal 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 a single, efficient sentence with no wasted words. It is front-loaded with the core purpose. However, the phrase 'multi-tenant mode' is ambiguous and could be considered unnecessary without further explanation, slightly reducing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'credential status' includes, the format of the response, or any error conditions. Given the complexity implied by 'multi-tenant mode' and the lack of structured data, more detail is needed to make this tool usable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'session_key' documented as a 'UUID v4 session key'. The description adds no additional meaning beyond this, such as where to obtain the session key or how it relates to credential status. Baseline 3 is appropriate given the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool's purpose as 'Get credential status for a session' which is clear but lacks specificity about what 'credential status' entails. It distinguishes from siblings by mentioning 'multi-tenant mode', but this is vague and doesn't clearly differentiate from tools like 'manage_auth' or 'set_session_credentials'.
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 'multi-tenant mode' but doesn't explain what this means or when it applies. There are no explicit instructions on prerequisites, timing, or comparisons with sibling tools like 'manage_auth' or 'refresh_access_token'.
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 clearing credentials, which hints at destructive behavior, but fails to detail critical aspects like whether this action is reversible, what happens to active operations, or any side effects. For a tool that likely terminates sessions, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action ('End a session') and adds necessary context ('clear credentials in multi-tenant mode') without waste. Every word earns its place, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity as a session termination operation with no annotations and no output schema, the description is incomplete. It lacks details on behavioral outcomes, error conditions, or return values, leaving gaps for an AI agent to understand the full context of use. This is inadequate for a potentially destructive tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'session_key' documented as a UUID v4. The description adds no additional meaning beyond this, such as where to obtain the session key or format details. Baseline 3 is appropriate since the schema does the heavy lifting, but the description doesn't compensate or enhance understanding.
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 ('End a session') and the resource ('session'), with the additional context of clearing credentials in multi-tenant mode. It distinguishes from siblings like 'manage_auth' or 'set_session_credentials' by focusing on termination rather than management or creation. However, it doesn't explicitly differentiate from all siblings, keeping it at a 4 rather than a 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 like 'manage_auth' or 'refresh_access_token', nor does it mention prerequisites or exclusions. It implies usage in multi-tenant mode but lacks explicit context for selection among siblings, resulting in minimal 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 login_customer_id override behavior but fails to describe critical aspects like whether this is a read-only or write operation, authentication requirements, rate limits, error handling, or what the tool returns. For a query execution tool with 8 parameters, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with just one sentence that directly addresses the tool's core functionality and one important behavioral note. Every word earns its place with zero wasted text, though this conciseness comes at the cost of completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex query execution tool with 8 parameters, no annotations, and no output schema, the description is severely incomplete. It doesn't explain what GAQL is, what data can be queried, authentication requirements, expected return format, error conditions, or how results are structured. The agent would need to rely heavily on the schema and external knowledge.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value by mentioning the login_customer_id override behavior, but doesn't provide additional context about parameter interactions, query syntax beyond what's in the schema examples, or practical usage patterns.
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 executes GAQL queries, which is a specific action with a defined resource (Google Ads Query Language). It distinguishes from siblings like 'gaql_help' (which likely provides assistance) and 'get_performance' (which may retrieve specific metrics). However, it doesn't explicitly differentiate from 'list_resources' which might also query 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 minimal guidance, only mentioning that login_customer_id overrides environment variables. It doesn't explain when to use this tool versus alternatives like 'list_resources' or 'get_performance', nor does it provide context about prerequisites, query limitations, or appropriate 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 the full burden of behavioral disclosure. It mentions one behavioral aspect: 'login_customer_id (aka MCC/manager account id) overrides env' which explains an authentication override mechanism. However, it fails to disclose critical behavioral traits: whether this is a read-only operation (implied by 'Get' but not explicit), potential rate limits, pagination behavior (though parameters exist), what performance metrics are returned, or any side effects. For an 11-parameter tool with complex filtering capabilities, this is insufficient 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 appropriately concise with two sentences. The first sentence states the core purpose with key parameter information, and the second provides important behavioral context about the login_customer_id override. There's no wasted verbiage or redundancy. However, it could be slightly more structured by separating purpose from parameter guidance more clearly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (11 parameters including nested objects, pagination controls, and filtering), absence of annotations, and no output schema, the description is incomplete. It doesn't explain what 'performance' data includes (metrics returned), how results are structured, pagination behavior despite having pagination parameters, or error conditions. For a data retrieval tool with rich filtering capabilities, users need more context about what they're getting and how to interpret results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already comprehensively documents all 11 parameters with descriptions, constraints, and defaults. The description adds minimal parameter semantics beyond the schema: it reinforces that 'login_customer_id' overrides environment variables, which is already implied in the schema description. No additional parameter meaning, relationships, or usage examples are provided. The baseline of 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get performance (level: account|campaign|ad_group|ad)' which specifies the verb ('Get') and resource ('performance') with the aggregation levels. It distinguishes itself from siblings by focusing on performance data retrieval rather than session management, query execution, or resource listing. However, it doesn't explicitly differentiate from potential performance-related alternatives that might exist in other contexts.
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 minimal usage guidance: it mentions that 'login_customer_id (aka MCC/manager account id) overrides env' which gives some context about parameter behavior. However, it offers no explicit guidance about when to use this tool versus alternatives (like execute_gaql_query for custom queries), no prerequisites, and no indication of when this tool would be preferred over other performance retrieval methods. The agent must infer usage from the tool name and parameters 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 the output format options (table, json, csv) and hints at filtering and limiting, but fails to describe key behavioral traits such as whether this is a read-only operation, potential rate limits, authentication requirements, or what happens if no resources match the filter. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.
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 concise and front-loaded, stating the core purpose in a single sentence. It efficiently covers the main functionality and output format without unnecessary details. However, the sentence structure is slightly dense and could be clearer, but it avoids waste and is appropriately sized for the tool's complexity.
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 (4 parameters, no output schema, no annotations), the description is partially complete. It covers the basic purpose and output format but lacks details on behavioral aspects, usage context, and how results are structured. Without an output schema, the description should ideally explain return values or examples, which it doesn't. This makes it adequate but with clear gaps for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, meaning the input schema already documents all parameters thoroughly. The description adds minimal value beyond the schema: it mentions 'output_format' options but doesn't explain their semantics further, and it implies filtering on resource name without adding details. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description provides some context but no significant additional meaning.
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: to list GAQL FROM-able resources via google_ads_field (category=RESOURCE, selectable=true) or list accounts. It specifies the verb ('List') and resources ('GAQL FROM-able resources' or 'accounts'), making the function evident. However, it doesn't explicitly distinguish this tool from sibling tools like 'execute_gaql_query' or 'gaql_help', which could provide similar or related functionality, leaving some ambiguity in 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. It mentions two possible outputs (resources or accounts) but doesn't explain the use cases for each or how this tool relates to siblings like 'execute_gaql_query' or 'gaql_help'. Without explicit when-to-use or when-not-to-use instructions, the agent lacks clear direction for 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 the full burden of behavioral disclosure. It states the action is a refresh operation (implying mutation) and mentions OAuth requirements, but doesn't cover critical aspects like whether this invalidates previous tokens, rate limits, error conditions, or what the refreshed token enables. This leaves significant gaps for a security-sensitive 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 a single, efficient sentence that front-loads the core purpose. The OAuth requirement is necessary context. There's no wasted text, though it could be slightly more structured for readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a security-critical mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after token refresh, whether the session_key must be valid, potential side effects, or return values. The OAuth requirement is helpful but doesn't compensate for the overall lack of operational context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents the single parameter 'session_key'. The description adds no additional parameter information beyond what's in the schema. This meets the baseline for high schema coverage, but doesn't provide extra value like explaining session key format or relationships.
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 ('Refresh') and resource ('access token for a session'), with the specific context 'multi-tenant mode' adding useful detail. It doesn't explicitly distinguish from sibling tools like 'end_session' or 'manage_auth', but the purpose is unambiguous.
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 when an access token needs refreshing in multi-tenant mode, but doesn't specify when to use this versus alternatives like 'manage_auth' or 'set_session_credentials'. It mentions prerequisites ('Requires GOOGLE_OAUTH_CLIENT_ID/SECRET'), which provides some contextual 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 states this establishes a session but doesn't describe what that session enables, how long it lasts, whether it's persistent, what permissions are required, or what happens if credentials are invalid. For a credential management tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core purpose without unnecessary words. It's appropriately sized and front-loaded with the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a credential/session management tool with no annotations, no output schema, and incomplete parameter documentation, the description is insufficient. It doesn't explain what a successful establishment returns, what errors might occur, or how this session integrates with other tools. The 'multi-tenant mode only' constraint is helpful but doesn't compensate for other missing context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 50% schema description coverage (only 'session_key' has a description), the description doesn't add any parameter-specific information beyond what's in the schema. It mentions 'Google Ads credentials' which aligns with the 'google_credentials' parameter but doesn't explain the structure or purpose of the credential fields. The description doesn't compensate for the schema coverage gap.
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 ('Establish a session') and target ('with Google Ads credentials'), and specifies the operational mode ('multi-tenant mode only'). It doesn't explicitly differentiate from sibling tools like 'manage_auth' or 'refresh_access_token', but the specificity of establishing a session with Google Ads credentials provides good clarity.
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 ('multi-tenant mode only') but doesn't provide explicit guidance on when to use this tool versus alternatives like 'manage_auth' or 'refresh_access_token'. It suggests this is for initial session establishment but doesn't clarify prerequisites or when other tools might be more 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?
No annotations are provided, so the description carries the full burden. It mentions 'local documentation and official Google Ads API links,' which hints at the tool's behavior (returning help content), but it doesn't disclose key traits like whether it's read-only, what format the output is in, rate limits, or authentication needs. For a tool with no annotations, this is a significant gap, warranting a 2.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded and concise: two sentences with zero waste. The first sentence states the purpose, and the second provides usage hints. Every sentence earns its place, making it efficient and well-structured.
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 has 2 parameters with full schema coverage and no output schema, the description is moderately complete. It covers the basic purpose and parameter usage but lacks details on behavioral traits (e.g., output format, error handling) and doesn't fully leverage the context of sibling tools. For a help tool with no annotations, it should do more to be fully helpful, so it's a 3.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters (topic with enum values and search). The description adds minimal value beyond the schema by suggesting how to use them ('Use topic for specific areas or search for keywords'), but it doesn't provide additional semantics like examples or deeper context. Baseline is 3 when schema coverage is high.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get GAQL help with local documentation and official Google Ads API links.' It specifies the verb ('Get') and resource ('GAQL help'), and distinguishes it from siblings like execute_gaql_query (which runs queries) and list_resources (which lists data). However, it doesn't explicitly differentiate from all siblings, such as get_performance or manage_auth, which is why it's a 4 rather than a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage guidance: 'Use topic for specific areas or search for keywords.' This suggests when to use each parameter, but it doesn't explicitly state when to choose this tool over alternatives (e.g., vs. general documentation or other help tools) or any prerequisites. Given the sibling tools include execute_gaql_query, more explicit differentiation would be helpful, so it's a 3.
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 describes actions (status, switch, refresh) and mentions executing gcloud steps or printing commands, which adds useful context. However, it doesn't cover critical aspects like permissions needed, rate limits, error handling, or what 'switch' and 'refresh' entail operationally, leaving gaps for a mutation 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, starting with the core purpose. It uses semicolons to list actions efficiently, though the sentence structure is slightly dense. Every phrase adds value without redundancy, making it concise but not perfectly polished.
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 no annotations and no output schema, the description is incomplete for a tool with 3 parameters and mutation capabilities. It covers the basic purpose and actions but lacks details on behavioral traits, return values, or error conditions. For a tool managing auth—a critical operation—this leaves significant gaps in understanding how to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The description adds marginal value by mentioning 'gcloud configuration name (for switch)' and 'execute gcloud steps', which aligns with but doesn't significantly expand beyond the schema. With high schema coverage, the baseline is 3, and the description doesn't provide extra semantic depth.
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 managing Google Ads authentication with specific actions (status, switch/refresh via gcloud, set_project/set_quota_project, optional oauth_login). It distinguishes itself from sibling tools like 'get_credential_status' and 'refresh_access_token' by offering broader auth management capabilities. However, it doesn't explicitly contrast with all siblings, keeping it at a 4 rather than a perfect 5.
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 for Google Ads auth management but doesn't explicitly state when to use this tool versus alternatives like 'get_credential_status' for checking status or 'refresh_access_token' for token renewal. It mentions optional oauth_login for creating ADC files, which provides some context, but lacks clear when/when-not guidance or named alternatives.
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:

[![mcp-google-ads-ts MCP server](https://glama.ai/mcp/servers/martechery/mcp-google-ads-ts/badges/card.svg)](https://glama.ai/mcp/servers/martechery/mcp-google-ads-ts)

Score Badge

Copy to your README.md:

[![mcp-google-ads-ts MCP server](https://glama.ai/mcp/servers/martechery/mcp-google-ads-ts/badges/score.svg)](https://glama.ai/mcp/servers/martechery/mcp-google-ads-ts)

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/martechery/mcp-google-ads-ts'

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