How to Use the Matomo MCP in LangChain

Q: How do I connect the Matomo MCP server to LangChain?

Install langchain-mcp-adapters and langgraph. Initialize a MultiServerMCPClient pointing to your Vinkius endpoint, extract the tools with client.gettools(), and pass them to your ReAct agent.

Q: Can LangChain agents track custom Matomo goals automatically?

Yes. Your agent can call getgoals to pull the active goal list for any site ID. It then uses that data to run continuous performance checks on specific conversion metrics.

Q: Why use LangChain for Matomo instead of a standard dashboard?

Dashboards are static. A LangChain agent actively queries getsitedetails and getvisitssummary, analyzes the data, and takes action based on your custom logic.

Connect Matomo analytics to your LangChain agents to build observable, multi-step data pipelines.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Matomo MCP to LangChain

Create your Vinkius account to connect Matomo to LangChain and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup Matomo with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chain Matomo MCP Server Queries

The Matomo MCP Server feeds raw web traffic data directly into your LangChain ReAct agents. Your agent starts by calling `list_sites` to grab active property IDs, then pipes those identifiers straight into `get_visits_summary` to pull baseline traffic metrics. You build automated reporting pipelines where the output of one tool dictates the next step in the chain. You get full visibility into these sequences. LangSmith logs the exact token usage and latency for every `get_top_pages` request. If a chain fails because a specific site ID was missing, you see the exact input and output payloads. It takes the guesswork out of debugging complex analytics agents.

Track Live User Behavior

Real-time traffic monitoring requires tools like `get_live_last_visits` to feed immediate session data to your agent. LangChain processes this incoming stream, allowing your agent to react to sudden traffic spikes or cart abandonment events as they happen. You don't wait for daily batch jobs to finish. Your agent can dig deeper when it spots an anomaly. It triggers `get_visitor_profile` to pull the complete history of a specific user. The agent uses this historical context to decide if an alert warrants human intervention or if it fits a known pattern of bot traffic.

Analyze Conversion Sources

Attribution modeling gets easier when your agent can query `get_goals` alongside traffic acquisition tools. Your LangChain setup pulls goal completion data and cross-references it with `get_top_referrers` and `get_top_socials`. The agent calculates which channels actually drive meaningful actions. You can connect this data to other external APIs in the same chain. Your agent pulls the top converting domains using `get_top_websites`, formats the data, and pushes it directly into your CRM or alerting system. The logic lives entirely in your code.

Setup guide

Set up Matomo MCP in LangChain

Prerequisites

Python 3.10+ installed
langchain-mcp-adapters + langgraph packages
Active Vinkius subscription with a valid endpoint token

1

Install dependencies
Run pip install langchain-mcp-adapters langgraph langchain-openai. The MCP adapters package converts MCP tools into native LangChain BaseTool objects.
2

Connect via HTTP transport
Use MultiServerMCPClient with "transport": "http" pointing to your Vinkius endpoint. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.
3

Create a ReAct agent
Pass the discovered tools to create_react_agent() from LangGraph. The agent automatically routes Matomo tool calls through the MCP protocol.
4

Run with any LLM
Swap ChatOpenAI for ChatAnthropic, ChatGoogleGenerativeAI, or any LangChain-compatible model. The MCP tools work identically across all providers.

agent.py

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

async with MultiServerMCPClient({
    "matomo-mcp": {
        "transport": "http",
        "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp",
    }
}) as client:
    tools = client.get_tools()

    agent = create_react_agent(
        ChatOpenAI(model="gpt-4o"),
        tools,
    )
    result = await agent.ainvoke({
        "messages": "List recent Matomo transactions"
    })
    print(result["messages"][-1].content)

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Matomo. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Matomo now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Matomo MCP in LangChain

Install `langchain-mcp-adapters` and `langgraph`. Initialize a `MultiServerMCPClient` pointing to your Vinkius endpoint, extract the tools with `client.get_tools()`, and pass them to your ReAct agent.

Yes. Your agent can call `get_goals` to pull the active goal list for any site ID. It then uses that data to run continuous performance checks on specific conversion metrics.

Dashboards are static. A LangChain agent actively queries `get_site_details` and `get_visits_summary`, analyzes the data, and takes action based on your custom logic.

It traces everything. You see the exact JSON payloads sent to `get_top_pages` and the latency of the response. This makes debugging your analytics chains straightforward.

Your visitor profiles and IP addresses remain secure within the Vinkius V8 Isolate Sandbox. The server processes `get_visitor_profile` requests ephemerally, ensuring sensitive user tracking data never leaks into persistent storage or unauthorized logs.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript