How to Use the LinearB MCP in LangChain

Q: How do I pass LinearB tool definitions directly into my LangChain agent?

You install the langchain-mcp-adapters package and initialize the MultiServerMCPClient pointing to the server URL. From there, call client.gettools() to retrieve tools like listconnectedrepos and pass them straight to your agent constructor.

Run multi-step engineering audits and track DORA metrics directly in your LangChain reasoning loops.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect LinearB MCP to LangChain

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chain-linked delivery audits with LangChain

Stop manually checking git and deployment logs to see if your team is actually shipping. This LinearB integration lets your LangChain agents fetch live repository data through `list_connected_repos` and immediately pipe it into downstream analysis chains. Your agent runs the check, gets the raw repo list, and decides if it needs to query deeper metrics without you writing glue code. The output of one step flows directly into the next. Your chain can grab active teams using `list_engineering_teams`, identify their active repositories, and instantly calculate cycle times. It turns static API endpoints into a living, reasoning pipeline that monitors your delivery health on autopilot.

Real-time incident correlation in agent loops

When a production issue hits, you do not have time to dig through multiple dashboards to find the bad release. This MCP Server lets your agent pull recent deployments via `list_software_deployments` and pair them with active incidents using `list_software_incidents` in a single execution chain. Your agent uses these tools to isolate the exact commit or deploy window that triggered the alert. By feeding these outputs into your LangChain decision chains, the agent can draft post-mortems or notify the on-call engineer with the exact context they need to fix the issue.

Automated DORA tracking in pipeline steps

Tracking DORA metrics is usually a chore that relies on clean git hygiene. You can automate this manual logging by letting your LangChain agent execute `record_new_deployment` and `record_new_incident` via this MCP Server directly from your CI/CD pipelines. The agent processes the pipeline run, parses the metadata, and writes the events directly to your dashboard. From there, you can query the aggregate data using `query_software_metrics` to verify if your delivery speed is actually improving or if you are just generating noise.

Setup guide

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

You install the `langchain-mcp-adapters` package and initialize the `MultiServerMCPClient` pointing to the server URL. From there, call `client.get_tools()` to retrieve tools like `list_connected_repos` and pass them straight to your agent constructor.

Yes, that is exactly what this setup is built for. Your agent runs `list_software_deployments` to find the latest release, then feeds that output directly into `record_new_incident` if a test failure is detected in the same chain run.

LangSmith traces every tool call, showing you the exact JSON body passed to `query_software_metrics`. You can see the latency, token count, and raw response payloads to optimize your prompt templates.

No, Vinkius handles the underlying API authentication for you. Your agent only needs a single endpoint token to execute any tool, from listing repositories to logging incidents.

The MCP Server runs in a secure, ephemeral V8 isolate sandbox that processes your engineering team structures and incident records on the fly. No repository metadata or deployment logs are stored on Vinkius servers, and the sandbox is destroyed immediately after your agent completes its execution chain.

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