Google Analytics MCP Server

Server Quality Checklist

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

Latest release: v2.11.3
Disambiguation5/5
Tools are clearly separated into distinct categories: schema exploration (search_schema, list/get dimension/metrics), data retrieval (get_ga4_data), and support (troubleshooting, skills, setup). No two tools have overlapping purposes, and each tool's description specifies when to use alternatives.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern with underscores (e.g., search_schema, list_dimension_categories, get_ga4_data). Verbs like search, list, get, setup are used predictably, and there is no mixing of camelCase or other conventions.
Tool Count5/5
The 10 tools are well-scoped for a GA4 analytics server, covering schema discovery, data retrieval, troubleshooting, analytical skills, and setup. Each tool serves a clear purpose without redundancy or unnecessary bloat.
Completeness5/5
The tool set covers the full workflow for GA4 data analysis: discover fields (via search or category browsing), retrieve data with intelligent patterns, access troubleshooting guides, fetch analytical recipes, and fix setup issues. No obvious gaps for the intended use case.
Average 4.7/5 across 10 of 10 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 1 of 3 community issues answered or closed in the last 6 months
- 126 commits in the last 12 weeks
- Last stable release on August 18, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations include readOnlyHint=true, openWorldHint=true, idempotentHint=true, which align with the description's interactive and re-initializing nature. The description adds context that it interacts with the user and re-initializes without a restart, which goes beyond annotations, but doesn't disclose potential side effects or details of the interaction.
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?
Compact, two-sentence description. Immediate front-loaded purpose, followed by actionable trigger condition. No filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and a true output schema, the description is sufficient. It explains the interactive process, trigger conditions, and that it re-initializes without restart. Could detail the exact steps or user prompts, but openWorldHint suggests flexible behavior; completeness is adequate.
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 tool has zero parameters, and the description explains it works by asking the user for needed input through the client. This adds value by clarifying that no schema parameters are needed and the tool handles collection dynamically.
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 fix a broken GA4 MCP setup by asking for missing inputs and re-initializing. It distinguishes itself from data retrieval tools by focusing on configuration/auth errors, but doesn't explicitly name a sibling alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly directs when to use: 'Call this whenever a configuration or authentication error is reported.' This is clear guidance and context, though it doesn't discuss when not to use, but the trigger condition is enough for typical use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is clear. The description adds useful context beyond annotations by noting the content is 'served from inside the server (no network needed),' which helps the agent understand latency and availability characteristics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact, front-loaded with the primary purpose, and uses a short Args block. Every sentence adds value: what it does, where it comes from, when to use it, and the valid topic values.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With one required parameter, explicit valid values, clear trigger scenarios, and an output schema already provided, the description covers all essential decision points. The agent can select and invoke this tool correctly without needing additional context.
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 input schema provides only the parameter name and type with no descriptions, so the description fully compensates by listing the valid values: 'setup', 'iam', or 'schema'. It also maps these to error classes in the usage guidance, making the parameter semantics actionable despite 0% schema description coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Returns') and a clear resource ('troubleshooting/setup guide for a topic'), plus a defined topic parameter. This distinguishes it from sibling schema/list/search tools by focusing on error-resolution guides rather than data retrieval or schema discovery.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use whenever you hit a schema error, dimension_filter parse error, IAM / 403 authorization error, or a boot-time setup error,' giving concrete trigger conditions. It does not mention when not to use the tool or name alternatives, so it stops short of a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the tool read-only and idempotent. The description adds valuable behavioral context by warning about the very large object size and clarifying the scope (complete schema including standard and custom dimensions/metrics). No contradiction with annotations.
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?
Two efficient sentences: the first conveys the core purpose, the second adds a critical warning and points to an alternative. Every word earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, no-output-schema tool with strong annotations, the description fully covers the essential context: what it returns, the size caveat, and the alternative for lighter-weight tasks. Nothing missing.
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 tool has zero parameters, and schema coverage is trivially 100%. The description adds no parameter detail because none exist, but it clearly explains what the return object contains, which is sufficient for a parameterless tool.
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 tool returns the complete schema for the configured GA4 property, including all dimensions and metrics. It distinguishes itself from siblings by explicitly noting it returns the full schema and pointing to search_schema for most discovery tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit guidance is provided: the warning about large size (10k+ tokens) signals caution, and 'Use search_schema for most discovery tasks' names the alternative and indicates when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to repeat safety traits. It adds valuable behavioral context by showing the exact return shape (a map of category to count), which is especially useful given no output schema is present.
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?
Three sentences, each with a distinct purpose: what it does, what it returns, and how to proceed. The description is front-loaded and contains no filler or redundant repetition of the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read-only list tool, the description covers the action, the return format, and the workflow with sibling tools. Annotations cover safety, and the return example compensates for the missing output schema. Nothing essential is omitted.
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 tool has zero parameters, so parameter semantics are inherently simple. The baseline is 4, and the description correctly focuses on behavior rather than inventing parameter explanations.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List all dimension categories') and clearly specifies the resource (GA4 property) and the added value (count of dimensions per category). It is easily distinguished from siblings like list_metric_categories and get_dimensions_by_category.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('first step in dimension exploration'), what to do next ('call get_dimensions_by_category'), and names an alternative (search_schema) for keyword-driven searches. This is exemplary usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true, and idempotentHint=true, so the safety profile is clear. The description adds behavioral context by explaining that it returns a full index when given an empty string and specific skills when given a slug, and it notes that skills contain exact dimensions, metrics, filters, and interpretation logic. This goes beyond the annotations by clarifying the tool's output behavior and its role in the workflow.
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 well-structured and front-loaded: it starts with the purpose, then explains usage, lists available skills, and provides examples. Every sentence adds value, and the usage examples are concise and clear. It 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.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no nested objects) and the presence of an output schema, the description is complete. It covers the purpose, usage, available skills, and examples. The output schema likely describes the return structure, so the description doesn't need to explain return values. The description fully equips the agent to use the tool correctly.
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 schema has only one parameter 'query' with no description, and schema description coverage is 0%. The description compensates by explaining that the query is a skill name (exact slug) or an empty string to browse the full index, and provides usage examples. This adds significant meaning beyond the bare schema, though it could be slightly more explicit about the exact format (e.g., case sensitivity).
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 tool fetches analytical recipes and how-to guides from the GA4 skills library, with a specific verb ('Fetch') and resource ('GA4 skills library'). It distinguishes itself from siblings by explicitly instructing to call it BEFORE get_ga4_data for domain-specific analysis, and lists available skills, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: it says to call this tool before querying get_ga4_data for any domain-specific analysis, and gives concrete examples of how to use it (empty string for full index, exact slug for specific skill). It also lists all available skills, which helps the agent decide when to use it. This is strong guidance that differentiates it from alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint and idempotentHint, and the description does not contradict them. The description adds a performance note about search_schema being 'faster and more targeted', which provides useful context beyond the annotations. However, it does not describe any additional side effects or requirements like authentication or rate limits, which would have enhanced transparency further.
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 well-structured and concise. It opens with the purpose, then describes the return format, provides usage guidance, and closes with parameter details. Each sentence contributes value without unnecessary fluff, making it easy to parse and act upon.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (single parameter, no output schema), the description is complete. It covers the return structure, parameter constraints, and alternative tool recommendation, providing sufficient context for an agent to decide when and how to use it. No critical information is missing.
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 schema only defines 'category' as a string, but the description enriches it by specifying that it must be an exact category name from list_dimension_categories and is case-insensitive. This adds crucial semantic detail beyond the schema, ensuring the agent understands the parameter's constraints and origin.
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 that the tool returns all dimensions in a specific category with their API names and descriptions. It distinguishes from the sibling get_metrics_by_category by focusing on dimensions and explicitly mentions an alternative tool (search_schema) for keyword-based searches, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: it requires an exact category name from list_dimension_categories and suggests using search_schema instead when a keyword is available, noting it is faster and more targeted. This clearly indicates when to use this tool versus alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint true, and the description adds return format context without contradicting annotations. It doesn't mention side effects, but read-only is implied and covered.
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?
Concise and well-structured: clear purpose, return format, usage note, and parameter explanation are all included without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description explicitly states the return format (dictionary mapping). It also provides source for category names and differentiates from alternative tools, covering all necessary context.
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 schema only specifies type string, but the description adds crucial semantics: it must be an exact category name from list_metric_categories and is case-insensitive, fully clarifying the parameter's meaning.
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?
States clearly that it returns all metrics in a specific category with API names and descriptions, and distinguishes from sibling tools like search_schema and get_dimensions_by_category.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit prerequisite (category must exactly match list_metric_categories) and recommends search_schema as a faster alternative for keyword searches, offering clear when-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint, and the description adds the exact return shape (metric_categories map with counts). It does not hide any mutation, side effects, or auth requirements; the behavior is fully transparent for a zero-parameter 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: purpose, return value, then usage alternatives. Every sentence earns its place, and the JSON return example is provided without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Even without an output schema, the description tells the agent exactly what to expect in the response. For a simple, read-only, no-argument listing tool, it covers purpose, output format, and related next steps, making it self-contained.
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 tool has zero parameters and the input schema is empty, so there is no parameter mapping for the description to enhance. Per the baseline rule for 0-parameter tools, a 4 is appropriate because the description correctly treats the operation as parameterless.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List'), names the exact resource ('metric categories'), and scopes it to 'this GA4 property' with an added count of metrics. It clearly distinguishes itself from siblings like list_dimension_categories and get_metrics_by_category.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says to use this as the first step in metric exploration, then directs the agent to get_metrics_by_category for browsing a chosen category. It also names search_schema as the better alternative when a keyword is already known, giving concrete when-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations (readOnlyHint, openWorldHint, idempotentHint) are consistent with the description's read-only nature. The description goes further by explaining the volume warning, estimate_only behavior, enable_aggregation with totals, and error handling, all without contradicting the annotations.
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?
Despite its length, the description is well-structured with clear sections (FIELD NAMES, DATE RANGES, SCOPE RULES, FILTER STRUCTURE, CRITICAL WORKFLOW). Each section addresses a specific challenge (naming pitfalls, date formats, incompatibilities, filter syntax), and no sentence is extraneous. The front-loaded purpose and workflow efficiently guide the agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is exceptionally complete for a complex GA4 API. It covers not only how to call the tool but also the prerequisite discovery steps, common mistakes, output structure (totals, warnings), and error recovery. There is no output schema, but the description clearly outlines what returns are expected, ensuring the agent has sufficient context.
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 explaining all 10 parameters: dimensions, metrics, date ranges, filter structure, limit, estimate_only, proceed_with_large_dataset, enable_aggregation, and intent. It provides formats, examples, and scope rules, making each parameter's meaning and usage clear.
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 tool's purpose: to retrieve GA4 data with built-in intelligence. It distinguishes itself from sibling tools (like search_schema) by focusing on data retrieval, and the workflow section explicitly positions it as the final step after schema discovery.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'CRITICAL WORKFLOW' section tells the agent to call search_schema and search_skills before using this tool, making the appropriate usage context explicit. It also provides detailed rules for date ranges, scope compatibility, and filter structure, guiding when and how to invoke the tool effectively.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnly and idempotent hints are present in annotations, and the description adds useful behavioral detail: results are ranked by relevance, limited to 10 matching fields, and returned in a specific top_results wrapper. This goes beyond the structured annotations and clearly informs the agent what will happen.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and well-structured: it opens with the core operation, then shows the return format, gives usage guidance, and closes with parameter semantics. Every line contributes value, with no filler or unnecessary repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Even though there is no output schema, the description explicitly provides the return shape and result structure. It also covers invocation purpose, parameter semantics, and alternatives. For a simple single-parameter, read-only search tool, the description is fully adequate and self-contained.
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 schema description coverage is 0%, but the description fully compensates by explaining the keyword parameter's meaning ('One or more keywords') and giving concrete examples ('user', 'campaign revenue'). This makes the single parameter semantically clear even though the schema itself is minimal.
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 a specific action ('Search for a keyword across all dimensions and metrics'), identifies the resource, and explains the ranked result of up to 10 fields with relevance scores. It also differentiates itself from sibling browsing tools by explicitly naming alternatives, making the purpose sharp.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use this tool: when you have a concept and need exact API field names before calling get_ga4_data. It also names the alternatives (list_dimension_categories, list_metric_categories) when the user wants to browse without a specific keyword, which is strong decision guidance.
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:

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

Score Badge

Copy to your README.md:

[![google-analytics-mcp MCP server](https://glama.ai/mcp/servers/surendranb/google-analytics-mcp/badges/score.svg)](https://glama.ai/mcp/servers/surendranb/google-analytics-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/surendranb/google-analytics-mcp'

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