How to Use the Arize AI MCP in LangChain

Q: How do I connect Arize AI to my LangChain agent?

You'll use the langchain-mcp-adapters library. Instantiate the MultiServerMCPClient with your Vinkius endpoint URL, then call gettools() on the client. The resulting tool list can be passed directly to your agent's constructor.

Q: Can my LangChain agent compare two models in Arize AI?

Yes, it can do this programmatically. The agent would use listmodels to find the models, then call getmetrics for each one. It can then compare the results in code to decide which model performs better on a specific metric.

Build observability chains for your models with LangChain. Connect Arize AI tools to automate monitoring and run evaluations.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Arize AI MCP to LangChain

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Build Automated Model Monitoring Chains

This isn't just about checking a dashboard. You build LangChain agents that react to your model's health in real time. An agent can `list_models`, grab the latest production version, and then call `get_metrics` to check for data drift. It’s an active, automated process, not a passive report. When a metric crosses a threshold you define, the chain continues. The agent can trigger a deeper investigation by calling `run_eval` with a specific dataset, or log the incident to another system. Every step, input, and output is visible in LangSmith, so you have a full trace of the agent's reasoning.

Run Dynamic Evaluations from Your Agent

The `run_eval` tool lets your LangChain agent decide when an LLM evaluation is necessary. Instead of just running on a schedule, your agent can connect events. For example, after a new model is pushed, the agent can automatically find it with `get_model` and immediately trigger a 'Toxicity' or 'Hallucination' evaluation. Your agent can get smarter about it, too. It can first call `list_datasets` to find the right evaluation set for the production environment, then pass that dataset's ID to the `run_eval` tool. This makes your evaluation pipeline dynamic, responding to what's actually happening with your models.

Ingest Telemetry with a LangChain MCP Server

The `ingest_log` tool closes the loop on observability. You can build a chain that takes raw output from another process, transforms it into a valid Arize JSON payload, and then has your agent call `ingest_log` to send it directly to your Arize space. This means your agent isn't just a read-only user of your observability platform. It actively contributes. It's a solid way to pipe in data from custom sources or even to log the performance and decisions of the LangChain agent itself back into Arize for analysis.

Setup guide

Set up Arize AI 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 Arize AI 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({
    "arize-ai-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 Arize AI 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 Arize AI. 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 Arize AI 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 Arize AI MCP in LangChain

You'll use the `langchain-mcp-adapters` library. Instantiate the `MultiServerMCPClient` with your Vinkius endpoint URL, then call `get_tools()` on the client. The resulting tool list can be passed directly to your agent's constructor.

Yes. Your agent can format its own operational data (like decisions or outputs) into a valid Arize payload. Then, it uses the `ingest_log` tool from this MCP server to push that telemetry into your Arize account for monitoring.

Build a chain that reacts to events. For instance, have the agent monitor for new models with `list_models`. When it finds one, it can use `run_eval` to kick off your standard battery of tests, like checking for PII or hallucinations.

Yes, it can do this programmatically. The agent would use `list_models` to find the models, then call `get_metrics` for each one. It can then compare the results in code to decide which model performs better on a specific metric.

The server only handles your model telemetry and configuration data from Arize AI. This includes metrics, evaluation results, and model metadata. All communication is over a secure, authenticated channel, and your Vinkius token manages access.

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