How do I use Matomo MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Matomo MCP Server show me the number of visits for the last 7 days" 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.

Matomo MCP Server

Q: Which integrations are available for this server?

Provides tools for querying the Matomo Analytics HTTP Reporting API, enabling LLM agents to run reporting queries, fetch historical trend analysis, inspect report metadata, and retrieve dynamically generated graph images directly from a Matomo instance.

by alexgenovese

Overview Schema Related Servers Score Discussions

TypeScript

Remote

Matomo MCP Server

License: MIT TypeScript Node.js Model Context Protocol

Matomo Direct MCP (Model Context Protocol) Server is a robust, lightweight TypeScript implementation that exposes the full power of the Matomo Analytics HTTP Reporting API directly to LLM agents.

Unlike intermediary solutions, this server connects directly to your Matomo instance, allowing clients (like Claude Desktop, Cursor, or custom MCP wrappers) to run reporting queries, fetch historical trend analysis, inspect report metadata, and retrieve dynamically generated graph images—all through beautifully typed, auto-documented MCP tools.

IMPORTANT

💡 Activation Keywords

This MCP server is always active in the hub. Agents automatically invoke it based on context using these trigger keywords:

analytics / Matomo / Piwik / statistics / traffic / visits ➔ triggers matomo_call (for any report) and matomo_list_report_metadata
visit summary / visitors / pageviews / bounce rate ➔ triggers matomo_get_processed_report with VisitsSummary.get
report metadata / report schema / available metrics ➔ triggers matomo_list_report_metadata, matomo_get_metadata
evolution / trend / time series / row evolution ➔ triggers matomo_get_row_evolution
chart / graph / image / png ➔ triggers matomo_get_image_graph
devices / browser / OS / countries / pages / keywords / referrer ➔ triggers matomo_get_processed_report with DevicePlugins/DevicesDetection/UserCountry/Referrers/etc.

🚀 Key Features

Direct Integration – No proxy databases or external authentication gateways; queries the Matomo HTTP API directly using your token_auth.
Full Reporting Coverage – Call any API method from any core or custom plugin.
Auto-Validated Inputs – Every tool payload is checked against strict JSON-Schema schemas via the MCP SDK and Zod.
Image Generation Support – Directly outputs binary PNG charts (ImageGraph.get) for visualization-capable LLM interfaces.
Resilience & Reliability – Configurable request timeouts and robust HTTP retry logic with exponential back-off.
Flexible Environments – Fully supports command-line flags, environment variables, and Docker deployment.

Related MCP server: Matomo MCP Server

🛠️ Technology Stack

Language: TypeScript (ESNext Modules, Strict Mode)
Runtime: Node.js (Recommended >= 22.0.0 for native fetch)
Server Framework: @modelcontextprotocol/sdk (v1.15.0)
Configuration & Validation: Zod (v3.23.8)
Development Tooling: tsx (watch mode/TS execution), typescript compiler (v5.6.x)

📐 Project Architecture

The Matomo Direct MCP Server operates as a STDIO transport process. It communicates via system standard input/output streams and is fully stateless.

┌─────────────────┐             STDIO              ┌─────────────────────────┐
│                 │  ◄───────────────────────────► │                         │
│   MCP Client    │  (List Tools, Call Tool)       │  Matomo Direct MCP Srv  │
│ (Claude/Cursor) │  ────────────────────────────► │  (TypeScript Process)   │
└─────────────────┘                                └───────────┬─────────────┘
                                                               │
                                                       HTTPS Fetch API
                                                       (token_auth, JSON)
                                                               │
                                                               ▼
                                                   ┌─────────────────────────┐
                                                   │   Matomo Analytics      │
                                                   │   HTTP Reporting API    │
                                                   └─────────────────────────┘

When started, the server:

Parses & Validates Configuration: Parses CLI flags or environment variables to find the MATOMO_HOST and MATOMO_TOKEN_AUTH.
Verifies Connectivity: Performs a non-blocking startup check against API.getMatomoVersion to ensure the host is reachable.
Exposes Typed Tools: Publishes structured JSON-schemas describing all report actions to the client.
Handles Requests: Receives tool invocations, dynamically builds requests (serializing parameters and authentication tokens), executes HTTP queries, detects content-types (JSON, XML, TSV, CSV, PNG), and formats clean, structured outputs back to the agent.

📦 Project Structure

mcp-matomo/
├── src/
│   ├── index.ts      # Standalone CLI entrypoint, configuration parsing, and startup
│   └── server.ts     # Core MCP server definition, API client, and tool handlers
├── dist/             # Compiled production JavaScript files (generated via tsc)
├── package.json      # Dependencies, compilation scripts, and metadata
├── tsconfig.json     # Strict TypeScript compiler options
├── .gitignore        # Comprehensive secrets & artifact ignore rules
└── README.md         # Documentation (this file)

🚥 Getting Started

Prerequisites

Node.js >= 22.0.0
npm >= 10.0.0
A running Matomo Analytics instance with an API token (token_auth).

Installation

Clone the repository to your local machine:

git clone https://github.com/alexgenovese/matomo-mcp.git
cd matomo-mcp

Install development and runtime dependencies:
```
npm ci
```

⚙️ Configuration

The server can be configured seamlessly using either Command Line Arguments or Environment Variables. CLI flags take priority over environment variables.

CLI Argument	Environment Variable	Default	Description
`--matomo-host=URL`	`MATOMO_HOST`	Required	Base URL of your Matomo instance (e.g., `https://analytics.yourcompany.com/`).
`--matomo-token=TOKEN`	`MATOMO_TOKEN_AUTH`	Required	Your Matomo secret API token (`token_auth`).
`--timeout=MS`	`REQUEST_TIMEOUT`	`30000`	HTTP request timeout in milliseconds.
`--retry=COUNT`	`RETRY_COUNT`	`3`	Maximum HTTP request retries.
`--retry-delay=MS`	`RETRY_DELAY`	`1000`	Initial retry delay in ms. Multiplied exponentially on consecutive failures.
`--format=FORMAT`	`MATOMO_DEFAULT_FORMAT`	`json`	Default response format for reporting queries (e.g., `json`, `xml`).

🏃 Running the Server

1. Local Development (with Hot Reloading)

Run the server directly from TypeScript source code using tsx:

npm run dev -- --matomo-host=https://your-matomo-url.com --matomo-token=your_token_auth

2. Production Build & Execution

Compile the TypeScript project to production-ready ES modules, then execute using Node:

# Compile TS to JS in /dist
npm run build

# Run stand-alone server
node dist/index.js --matomo-host=https://your-matomo-url.com --matomo-token=your_token_auth

3. Running with Docker

You can containerize and run the server inside a Docker environment:

# Build the Docker image
docker build -t matomo-mcp .

# Run the container
docker run -i --rm -e MATOMO_HOST="https://your-matomo-url.com" -e MATOMO_TOKEN_AUTH="your_token_auth" matomo-mcp

🛠️ MCP Tools Overview

The server exposes six highly focused, dynamically parameterized tools:

1. `matomo_call`

Generic, escape-hatch endpoint to run any Matomo HTTP API reporting method.

Required Arguments:
- method (string): The Module.action signature (e.g., VisitsSummary.get or UsersManager.getUsers).
Optional Arguments:
- params (object): Key-value pairs representing request arguments.
- format (enum): Output serialization format (json, xml, csv, tsv, html, rss, original, png).

2. `matomo_list_report_metadata`

Fetch the complete metadata suite of compatible reports for a site.

Required Arguments:
- idSite (integer): ID of the Matomo website.
Optional Arguments:
- period, date, language, showSubtableReports, hideMetricsDoc.

3. `matomo_get_metadata`

Query granular metadata schemas, documentation, and specific column dimensions of a single report action.

Required Arguments:
- idSite (integer), apiModule (string), apiAction (string).

4. `matomo_get_processed_report`

Retrieve high-level processed metrics, calculations, and tables complete with arithmetic.

Required Arguments:
- idSite (integer), apiModule (string), apiAction (string).
Optional Arguments:
- segment (segment filter string), flat (boolean), expanded (boolean), filter_limit (integer).

5. `matomo_get_row_evolution`

Analyze historical trend lines for a specific report row label over time.

Required Arguments:
- idSite (integer), apiModule (string), apiAction (string), label (string).

6. `matomo_get_image_graph`

Acquire raw PNG chart visualizations directly generated by Matomo's Graph Engine.

Required Arguments:
- idSite (integer), apiModule (string), apiAction (string).
Optional Arguments:
- graphType (evolution, horizontalBar, verticalBar, pie), width, height, columns.

🔌 Integration Guides

Claude Desktop Integration

To register this server with your local Claude Desktop app, edit your configuration file (usually located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS, or %APPDATA%\Claude\claude_desktop_config.json on Windows) and add the following entry:

{
  "mcpServers": {
    "matomo-direct-mcp": {
      "command": "node",
      "args": [
        "/Users/alexgenovese/Documents/GitHub/mcp/mcp-matomo/dist/index.js",
        "--matomo-host=https://your-matomo-instance.com",
        "--matomo-token=YOUR_MATOMO_TOKEN_AUTH"
      ]
    }
  }
}

Note: Ensure you have compiled the server beforehand by running npm run build.

💻 Development Workflow

Coding Standards

We enforce highly clean, structured, and modern development standards:

Strict Types: Explicit typings everywhere; any is restricted only to generic API parsing.
Modular ES Imports: Node.js ES Modules are strictly enforced. Relative file imports must include the .js extension (e.g. import { Server } from "./server.js").
Robust Error Handling: Network failures are monitored and retried using structured back-offs, while standard error objects are printed to standard error (console.error) so as not to corrupt the STDIO transport on standard output.

Linting

Validate codebase health and alignment to guidelines:

npm run lint

🤝 Contributing

Contributions are welcome! Please follow these simple steps to contribute:

Fork the repository and create your feature branch (git checkout -b feature/amazing-feature).
Verify changes build perfectly and conform to standard formatting guidelines.
Open a Pull Request detailing the purpose and scope of your modifications.

📄 License

This project is licensed under the MIT License - see the package.json file for licensing declarations.

Available Tools

6 tools

matomo_callB

Esegue qualsiasi metodo dell'HTTP Reporting API di Matomo (es. VisitsSummary.get, SitesManager.getSitesWithViewAccess). Parametri: method, params, format.

ParametersJSON Schema

Name	Required	Description	Default
`format`	No	Formato di risposta (json, xml, csv, tsv, html, rss, original, png)	json
`method`	Yes	Metodo nel formato Module.action (es. VisitsSummary.get)
`params`	No	Parametri della richiesta API

TDQS

B3.2/5.0

Behavior2/5

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

With no annotations, the description bears full responsibility for behavioral disclosure. It only states that the tool executes methods, without mentioning side effects, authentication requirements, rate limits, or error behavior.

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 concise (two sentences), front-loads the purpose, and lists parameters efficiently without extraneous words.

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 generic API caller with nested parameters and no output schema, the description is insufficient. It lacks guidance on constructing the 'params' object, error handling, and authentication context, leaving the agent underinformed.

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 coverage is 100%, so all parameters are documented in the schema. The description merely lists parameter names without adding new semantics, meeting the baseline but adding no extra value.

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 executes any Matomo HTTP reporting API method, with specific examples (VisitsSummary.get, SitesManager.getSitesWithViewAccess). It implies a generic nature, distinguishing it from sibling tools that cover specific methods.

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 sibling tools like matomo_list_report_metadata or matomo_get_processed_report. There is no mention of prerequisites, alternatives, or exclusions.

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

matomo_get_image_graphC

Genera immagine PNG dello grafico tramite ImageGraph.get.

ParametersJSON Schema

Name	Required	Default
`date`	No	today
`width`	No
`height`	No
`idGoal`	No
`idSite`	Yes
`labels`	No
`period`	No	day
`columns`	No
`segment`	No
`apiAction`	Yes
`apiModule`	Yes
`graphType`	No
`idSubtable`	No

TDQS

C2/5.0

Behavior2/5

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

No annotations are provided, and the description fails to disclose any behavioral traits (e.g., destructive actions, rate limits, data scope). The description carries the full burden but adds minimal transparency beyond the basic purpose.

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

Conciseness2/5

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

The description is extremely short (one sentence in Italian), but this brevity omits essential details. It is under-specified rather than concise, sacrificing usefulness.

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

Completeness1/5

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

With 13 parameters, no output schema, and no parameter descriptions, the description is severely incomplete. An agent cannot reliably use this tool without additional documentation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 13 parameters with no description coverage (0%). The description does not explain any parameters, including required ones like apiModule and apiAction, leaving the agent without critical usage context.

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 generates a PNG image of a graph via ImageGraph.get, but it is in Italian and does not elaborate on the type of graphs or metrics. Compared to siblings like matomo_get_processed_report, the purpose is discernible but lacks clarity.

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

Usage Guidelines2/5

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

No guidance on when to use this tool versus alternatives such as matomo_get_processed_report. The description does not provide any context for selecting this tool.

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

matomo_get_metadataC

Recupera metadati per report specifico tramite API.getMetadata. Include schema, unità di misura, documenti.

ParametersJSON Schema

Name	Required	Default
`date`	No	today
`idSite`	Yes
`period`	No	day
`language`	No
`apiAction`	Yes
`apiModule`	Yes
`hideMetricsDoc`	No
`showSubtableReports`	No

TDQS

C2.6/5.0

Behavior2/5

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

No annotations are provided, so the description must carry the burden of disclosing behavioral traits. It lacks information on side effects, authentication needs, rate limits, or any constraints. It only states what the tool does, not how it behaves.

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

Conciseness4/5

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

The description is very short and to the point, with no unnecessary words. It front-loads the action and result. However, it could be slightly expanded without losing conciseness to improve completeness.

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

Completeness1/5

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

Given the complexity (8 parameters, no output schema, no annotations), the description is severely lacking. It does not explain how to use the parameters or what the response looks like, leaving the agent to guess or rely on external knowledge.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage, the description should explain parameters. It does not mention the key parameters apiModule and apiAction, nor does it clarify the role of date, period, or boolean options. The brief mention of 'schema, unità di misura, documenti' hints at output but not input semantics.

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 it retrieves metadata for a specific report via API.getMetadata, and includes what is returned (schema, unit of measure, documents). It distinguishes from siblings like matomo_list_report_metadata by implying it targets a specific report, though it could be more explicit.

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 does not provide guidance on when to use this tool versus alternatives. No mention of prerequisites, when not to use, or how it compares to matomo_list_report_metadata or matomo_get_processed_report.

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

matomo_get_processed_reportC

Recupera report completo processato con dati numerici tramite API.getProcessedReport.

ParametersJSON Schema

Name	Required	Default
`date`	No	today
`flat`	No
`idGoal`	No
`idSite`	Yes
`period`	No	day
`segment`	No
`expanded`	No
`language`	No
`apiAction`	Yes
`apiModule`	Yes
`idSubtable`	No
`filter_limit`	No
`showMetadata`	No
`filter_truncate`	No

TDQS

C2.4/5.0

Behavior2/5

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

Without annotations, the description carries full burden. It only states that the tool retrieves a report, but does not disclose behavioral traits such as side effects, permissions, rate limits, or constraints. Minimal transparency.

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

Conciseness3/5

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

The description is a single sentence, which is concise but lacks structure or front-loading of key information. For a tool with many parameters, it is under-specified and does not earn its length.

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

Completeness1/5

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

Given the complexity (14 parameters, no output schema, no annotations), the description is extremely incomplete. It does not explain return values, required parameters, or how to use the tool effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not explain any of the 14 parameters. This fails to add meaning beyond the input schema, which itself lacks descriptions.

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

Purpose4/5

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

The description states the action (recupera = retrieves) and resource (report completo processado con dati numerici), making the purpose clear. However, it does not differentiate from sibling tools like matomo_list_report_metadata, which may also retrieve report 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?

No guidance is provided on when to use this tool versus alternatives. There is no context for preferred use cases or exclusions.

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

matomo_get_row_evolutionC

Analizza evoluzione temporale di una singola riga di report tramite API.getRowEvolution.

ParametersJSON Schema

Name	Required	Default
`date`	No	today
`label`	Yes
`idGoal`	No
`idSite`	Yes
`period`	No	day
`segment`	No
`apiAction`	Yes
`apiModule`	Yes
`idSubtable`	No

TDQS

C2.6/5.0

Behavior2/5

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

With no annotations, the description must disclose behavioral traits. It only states the basic purpose without mentioning side effects, read-only nature, authorization requirements, or limits. This is insufficient for an agent to understand the tool's 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 a single sentence that efficiently conveys the core purpose. It is front-loaded and concise, with no extraneous 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?

Given the tool has 9 parameters (4 required) and no output schema, the description is incomplete. It does not explain return values, how the evolution is presented, or any other context beyond the basic function.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% and the description does not explain any parameters. It fails to add meaning beyond the schema structure. For a tool with 9 parameters, this omission is critical.

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 analyzes temporal evolution of a single report row, using API.getRowEvolution. It specifies the verb 'Analizza' and the resource 'evoluzione temporale di una singola riga di report'. However, it does not explicitly differentiate from sibling tools like matomo_get_processed_report, which might have overlapping functionality.

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

Usage Guidelines2/5

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

No guidance is provided on when to use this tool versus alternatives. The description only states what it does, not the context or conditions for its use.

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

matomo_list_report_metadataB

Recupera lista completa di report compatibili da API.getReportMetadata. Utile per esplorazione.

ParametersJSON Schema

Name	Required	Description	Default
`date`	No		today
`idSite`	Yes	ID del sito Matomo
`period`	No		day
`language`	No
`hideMetricsDoc`	No
`showSubtableReports`	No

TDQS

B3.3/5.0

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 reveals the operation is a retrieval from an API endpoint, but does not mention side effects, required permissions, error behavior, or output structure. This is insufficient for an agent to anticipate the tool's behavior reliably.

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: two sentences that state the action and its purpose. Every word contributes meaning. No fluff or redundant 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 tool with 6 parameters and no output schema, the description is too minimal. It does not explain what data the returned list contains, how to interpret the metadata, or how the parameters filter the results. An agent would lack context to use this tool effectively in a real scenario.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 17% (idSite has a description). The tool description adds no parameter-level information beyond what is in the schema. With 6 parameters total, the agent receives no guidance on how to use date, period, language, hideMetricsDoc, or showSubtableReports, which would be essential for effective invocation.

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: 'Recupera lista completa di report compatibili da API.getReportMetadata. Utile per esplorazione.' This is a specific verb ('retrieves') and resource ('list of compatible reports') with the source API, making it easy for an agent to understand what it does and distinguish from siblings like matomo_get_metadata or matomo_get_processed_report.

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 mentions 'Utile per esplorazione' (useful for exploration), implying a general exploratory context. However, it does not explicitly state when to use this tool vs. alternatives, nor does it provide any exclusions or prerequisites. Sibling tools are listed but not compared.

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

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

6 tool updatesv1.0.0Jul 30, 2026
- First observedmatomo_call
- First observedmatomo_get_image_graph
- First observedmatomo_get_metadata
- First observedmatomo_get_processed_report
- First observedmatomo_get_row_evolution
- First observedmatomo_list_report_metadata

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3/5.0

Disambiguation4/5

Tools have distinct purposes: generic API call, listing reports, getting metadata, processed reports, row evolution, and image graphs. However, matomo_call could be used to replicate the others, creating slight ambiguity.

Naming Consistency4/5

All tools start with 'matomo_' followed by a verb phrase. Most use 'get' for retrieval, but 'list' and 'call' deviate slightly. Pattern is clear and mostly consistent.

Tool Count5/5

6 tools is well-scoped for a Matomo analytics server. The set covers key interactions without being overwhelming, and the generic matomo_call fills any gaps.

Completeness5/5

Tools cover listing, metadata, processed data, row evolution, and graph generation. The generic matomo_call ensures any missing API method is accessible, making the surface complete.

Maintenance

ActivityStale

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

climbpast
io.github.archievi
Read and edit GA4, Search Console and Google Tag Manager from any MCP client. 29 tools.
Marketing Search Data Platforms
1
MetrifyrOAuth
cloud.metrifyr
SEO & marketing toolkit for AI agents: GA4, Search Console, AdSense, GTM, PageSpeed, Trends.
Monitoring Search Marketing
2
Betterlytics
io.betterlytics
Query your Betterlytics web analytics from AI agents: traffic, funnels, journeys, errors, uptime.
Monitoring Observability
1170
Vee3 A
io.github.Vee3io
Hosted MCP with 91 agent tools: X, domains, SEO, Maps, Trends, Search, YouTube, TikTok, and more.
Social Media Browser Automation Marketing
26921

Related MCP Servers

Matomo MCP Server
Monitoring Observability
thichcode
A
license
A
quality
D
maintenance
A Model Context Protocol server that provides tools to interact with Matomo Analytics API, enabling management of sites, users, goals, segments, and access to analytics reports through a MCP interface.
Updated 3 months ago (2026-06-21 17:19 UTC)
11
15
ISC
Matomo MCP Server
openmost
-
license
Not graded
quality
Not graded
maintenance
Enables AI models to interact with Matomo analytics through a complete MCP server implementation. Provides tools for retrieving analytics data, managing sites, and generating reports with zero configuration setup.
Updated a year ago (2025-09-11 13:22 UTC)
-
MCP Server for Google
Marketing Developer Tools Data Platforms
harshfolio
A
license
Not graded
quality
F
maintenance
Enables LLMs to interact with Google Analytics 4 data through the Google Analytics Data API, supporting standard reports, real-time data, and metadata retrieval.
Updated a year ago (2025-03-29 09:38 UTC)
19
MIT
Google Analytics MCP Server
Monitoring Marketing
Seey215
A
license
B
quality
D
maintenance
Enables LLM applications to query Google Analytics 4 data through standard MCP interfaces, supporting real-time data, custom reports, and metadata discovery.
Updated 8 months ago (2026-01-12 12:06 UTC)
5
78
1
MIT

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/alexgenovese/matomo-mcp'

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

Matomo MCP Server

💡 Activation Keywords

🚀 Key Features

🛠️ Technology Stack

📐 Project Architecture

📦 Project Structure

🚥 Getting Started

Prerequisites

Installation

⚙️ Configuration

🏃 Running the Server

1. Local Development (with Hot Reloading)

2. Production Build & Execution

3. Running with Docker

🛠️ MCP Tools Overview

1. matomo_call

2. matomo_list_report_metadata

3. matomo_get_metadata

4. matomo_get_processed_report

5. matomo_get_row_evolution

6. matomo_get_image_graph

🔌 Integration Guides

Claude Desktop Integration

💻 Development Workflow

Coding Standards

Linting

🤝 Contributing

📄 License

Available Tools

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

1. `matomo_call`

2. `matomo_list_report_metadata`

3. `matomo_get_metadata`

4. `matomo_get_processed_report`

5. `matomo_get_row_evolution`

6. `matomo_get_image_graph`