How to Use the GrowingIO MCP in LangChain

Q: How do I connect the GrowingIO MCP Server to my LangChain agents?

Install the adapter package with pip install langchain-mcp-adapters langgraph. Then, initialize the client using MultiServerMCPClient with your Vinkius endpoint URL and pass the tools directly to your LangChain agent constructor.

Q: Can a LangChain agent query specific user segments from GrowingIO?

Yes, your LangChain agent can call listsegments to find active cohorts. It can then pass those segment IDs to getsegmentusers to pull the list of matching user profiles for further analysis.

Q: How does LangChain handle complex funnel debugging with GrowingIO?

The LangChain agent uses a ReAct loop to first call getfunnel to pinpoint the drop-off step. Once it identifies the weak point, it automatically triggers getmetrics to analyze user actions at that specific stage.

Run multi-step product analytics chains and track user conversion funnels directly inside your LangChain pipelines.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect GrowingIO MCP to LangChain

Create your Vinkius account to connect GrowingIO 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 GrowingIO with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chaining GrowingIO Events in LangChain

Stop copying JSON from GrowingIO dashboards to fix LangChain marketing drops. This MCP Server lets your LangChain agent fetch raw event details with `get_event` and feed that data directly into your messaging templates. You build a LangChain pipeline where the output of your GrowingIO user queries instantly shapes the next prompt. You get full visibility over this GrowingIO data flow through LangSmith tracing. See exactly which raw metrics were pulled with `get_metrics` and watch how your LangChain agent uses that context to write targeted follow-ups. No black boxes, just clear steps.

Automated Funnel Analysis Pipelines

When conversions drop, you've got to find the leak fast inside your LangChain pipeline. Use `get_funnel` to pull conversion funnel steps from GrowingIO and let your agent analyze the drop-off rates on the fly. The LangChain agent can automatically trigger a secondary chain to inspect specific user segments when it spots a metric dip. By calling `list_segments` and `get_segment_users`, your LangChain pipeline identifies the exact group of slipping GrowingIO users. It does this without manual exports, keeping your targeting loops tight and fast.

Dynamic Tracking Audits

Tracking setups break the second developers touch the front-end code, which ruins your LangChain automation. This MCP Server integration lets your LangChain pipeline run routine checks on your GrowingIO setup by calling `list_variables` and `list_log_sources`. Your LangChain agent compares active GrowingIO variables against your codebase to flag missing triggers. You can also query `list_events` to verify that your critical GrowingIO conversion points are still active. It keeps your data clean without requiring data engineers to manually audit the LangChain setup every week.

Setup guide

Set up GrowingIO 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 GrowingIO 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({
    "growingio-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 GrowingIO 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 GrowingIO. 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 GrowingIO 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 GrowingIO MCP in LangChain

Install the adapter package with `pip install langchain-mcp-adapters langgraph`. Then, initialize the client using `MultiServerMCPClient` with your Vinkius endpoint URL and pass the tools directly to your LangChain agent constructor.

Yes, your LangChain agent can call `list_segments` to find active cohorts. It can then pass those segment IDs to `get_segment_users` to pull the list of matching user profiles for further analysis.

The LangChain agent uses a ReAct loop to first call `get_funnel` to pinpoint the drop-off step. Once it identifies the weak point, it automatically triggers `get_metrics` to analyze user actions at that specific stage.

Yes, you can track every tool execution using LangSmith. It logs the inputs and outputs of calls like `list_events` so you can monitor latency and token costs.

Vinkius runs the server in an isolated V8 sandbox, ensuring your event details, user segments, and tracking variables never leak. Your API credentials stay encrypted on our platform, and we never store the query results returned by `get_segment_users`.

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