How to Use the NOAA Tides & Currents API MCP in LangChain

Q: How can I use the NOAA Tides & Currents API with LangChain to build a sequential check?

You build a chain. Start with checkapistatus. If the result is good, the next step in your chain can call gettidepredictions or getwaterlevels. LangChain manages passing the output from one tool as input to the next.

Build LangChain agents that react to live maritime data. Check water levels, get tide predictions, and make decisions based on real-world conditions.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect NOAA Tides & Currents API MCP to LangChain

Create your Vinkius account to connect NOAA Tides & Currents API 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 NOAA Tides & Currents API with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chain Tool Calls for Sequential Analysis

This isn't about single API calls. It's about building chains of logic. Your LangChain agent can first run `check_api_status` to confirm the NOAA service is up. If it is, the next link in the chain calls `get_tide_predictions` for the upcoming week. From there, your agent can loop through the results, automatically calling `get_water_levels` and `get_water_temperature` at each predicted high tide. You're not just fetching data; you're building a process that validates itself and executes a multi-step analysis without manual intervention.

Create Agents That Decide What Data to Get

Give your agent a goal, not a script. Ask it, "Is it safe for a vessel with a 10-meter draft to transit station 9414290 in the next two hours?" The agent itself decides what's needed. It knows to call `get_water_levels` for the current depth. It might also call `get_water_temperature` to adjust for water density, giving you a more accurate clearance calculation. The agent reasons over the tools, picks the right ones for the job, and synthesizes an answer. You define the objective, and LangChain figures out the 'how'.

Use This LangChain MCP Server for Maritime Ops

Build an automated alert system. Have an agent monitor a specific station by calling `get_water_levels` every 15 minutes. If the level drops below a threshold you define, the chain triggers an action, like sending a notification to a Slack channel. This goes beyond simple monitoring. You can create chains that compare real-time data with historical trends. For instance, an agent could check if the current `get_air_temperature` is unusually high for the date, flagging potential anomalies that affect shipping or environmental conditions.

Setup guide

Set up NOAA Tides & Currents API 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 NOAA Tides & Currents API 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({
    "noaa-tides-currents-api-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 NOAA Tides & Currents API 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 NOAA Tides & Currents. 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 NOAA Tides & Currents API 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 NOAA Tides & Currents API MCP in LangChain

You build a chain. Start with `check_api_status`. If the result is good, the next step in your chain can call `get_tide_predictions` or `get_water_levels`. LangChain manages passing the output from one tool as input to the next.

Yes, that's the point of a ReAct agent. You provide it the list of tools from this MCP Server, and based on your prompt, it selects the right one. For example, it will choose `get_tide_predictions` for future-looking questions and `get_water_levels` for current conditions.

You can hardcode the station ID for a specific task or let the agent infer it from the user's query. For multi-step chains, the station ID can be an input variable that's passed to each tool call, like `get_water_levels` and `get_water_temperature` for the same location.

When you connect your agent to a service like LangSmith, every tool call is traced automatically. You'll see the exact inputs and outputs for each call to `get_water_levels` or any other tool, which is great for debugging your agent's reasoning.

Your agent only sends the necessary parameters, like the NOAA station ID and desired date range, to the MCP Server. Vinkius processes these requests in an ephemeral sandbox. No query data or personally identifiable information is stored.

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