How to Use the LA Metro MCP in LangChain

Build transit-aware reasoning chains for your LangChain agents to navigate Los Angeles.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect LA Metro MCP to LangChain

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chain Bus and Rail Data

This isn't about single API calls. It's about building logic. Your LangChain agent can start with `get_bus_routes` to find a route ID, feed that into `get_bus_stops` to find stops near a destination, then call `get_stop_predictions` to see what's coming. The point is, you don't hardcode this sequence. You give the agent the tools. The agent figures out the chain of calls needed to answer a complex question like, "What's the next bus I can catch to get near The Getty?"

Plan Trips with Your LangChain Agent

Let your agent plan a trip the way a person would. It can use `get_rail_to_rail` to map out the main journey from North Hollywood to Santa Monica. But before it gives you the final answer, it can automatically double-check `get_service_alerts` to make sure there aren't any surprise closures on the Expo Line. This creates a more reliable plan. The agent isn't just fetching data; it's performing a series of checks and balances. It's the difference between a simple data lookup and genuine trip planning.

Monitor the Live Network

Give your agent a complete picture of the LA Metro network in real time. It can combine the output from `get_bus_locations` and `get_rail_vehicle_positions` to track everything that's moving. It sees the whole board. From there, it can get smarter. The agent can compare the live data against the published schedule from `get_bus_schedule` to spot delays before they're officially announced. This turns your agent from a simple data puller into a real-time transit analyst.

Setup guide

Set up LA Metro 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 LA Metro 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({
    "la-metro-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 LA Metro 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 LA Metro. 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 LA Metro 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 LA Metro MCP in LangChain

You provide your agent with the tools from this MCP server, like `get_bus_stops` and `get_stop_predictions`. Then you ask it a question in plain English, like "when's the next bus at stop 1234?" LangChain's ReAct framework will figure out which tools to call in what order to get you the answer.

Yes. The agent can chain tools together to create a full itinerary. It might use `get_rail_to_rail` for the train portion and then check `get_bus_routes` and `get_bus_stops` to figure out the first and last mile.

The MCP server gives your agent a standard set of tools it already understands. You don't have to write custom wrappers, handle authentication, or parse weird API responses. You just give the tools to the agent and it knows how to use them.

You can configure your LangChain agent to handle tool errors gracefully. It can retry the call, try a different tool, or report back to you that it couldn't get the data. It's more resilient than a simple script that would just crash.

The server itself is stateless and doesn't store your data. When your agent calls a tool like `get_rail_to_rail` with start and end station IDs, that data is used for the transaction and then discarded. Vinkius doesn't log or store the contents of your API calls.

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