LangGraph Cloud MCP for AI. Pinpoint State Failures in Your AI Workflows

Q: How do I check if my agents are running on a schedule using listcrons?

You use listcrons to see every scheduled background job configured for your account. This tells you which agents run automatically and how often they fire.

Q: What is the difference between createrun and getrun?

You use createrun when you want to start a brand new execution with specific input data. You use getrun later to check on that run, getting its status and final output.

Q: Can I list all available assistants using listassistants?

Absolutely. listassistants gives you a clean directory of every compiled agent configuration, so you know exactly what tools are deployed in your LangGraph Cloud account.

Q: If an agent gets stuck in a loop, how do I stop it using cancelrun?

You interrupt the process by passing the run ID to cancelrun. This immediately terminates the graph execution. You can use this tool if you need to prevent resource waste or correct flawed logic mid-process.

Q: What information does listthreads provide about my current conversations?

listthreads shows all active thread IDs and their basic status. It's your primary way to monitor the existence of long-term memory buffers across your application, even if they haven't been actively used recently.

Q: How can I use listruns to audit a specific conversation thread?

listruns retrieves a chronological list of all execution attempts tied to one thread ID. This is crucial for auditing, letting you see if the agent tried multiple times or failed on previous runs.

Q: What exact variables does getthreadstate return?

getthreadstate returns the precise state graph and all associated variables at a given moment. It shows developers exactly which data inputs, or internal flags, are available for manual inspection or override.

Claude

ChatGPT

Cursor

Gemini

Windsurf

VS Code

JetBrains

Vercel

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Connect to your AI in seconds.

LangGraph Cloud provides total visibility into your stateful AI agents, letting you manage multi-step workflows and complex graph executions through natural conversation.

You can monitor running processes, inspect a thread's exact variables at any point, or manually approve steps for human review; it’s built for debugging reliable, production-grade agent systems.

What your AI can do

List assistants

Retrieves a list of all compiled, deployed LangGraph agent configurations.

Cancel run

Stops an ongoing graph execution immediately if it's running too long or failing.

Create thread

Sets up a new, blank conversation thread to hold state for future interactions.

+ 7 more capabilities included

Monitor Agent Performance

View status updates and full details for any running agent execution using get_run.

Maintain Conversation Memory

Create new conversation threads or check the existing state of a thread to keep long-term memory active via create_thread.

Inspect Workflow State

Retrieve the exact data, variables, and messages that an agent has accumulated for a specific conversation using get_thread_state.

Control Execution Flow

Manually interrupt a running graph execution with cancel_run, or force the system to skip ahead by updating state with update_thread_state.

Manage System Assets

List all deployed agent assistants using list_assistants, or check scheduled automation jobs via list_crons.

Ask an AI about this

Included with Plan

Waiting for input…

AI Agent

LangGraph Cloud (Stateful AI Agents) with 10 Tools

Use these tools to manage the lifecycle of complex agents: from starting a run to inspecting the exact state variables and overriding workflow steps.

Make your AI actually useful.

Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.

Start using LangGraph Cloud (Stateful AI Agents) on Vinkius

List Assistants

Retrieves a list of all compiled, deployed LangGraph agent configurations.

Cancel Run

Stops an ongoing graph execution immediately if it's running too long or failing.

Create Thread

Sets up a new, blank conversation thread to hold state for future interactions.

Create Run

Starts a fresh agent execution on a specific thread using defined input data.

Get Run

Pulls all details and the current status of a single, specific graph run.

Get Thread State

Gathers the complete variable set and message history for an active conversation thread.

List Crons

Lists all background jobs that are scheduled to run agents automatically at a specific time.

List Runs

Shows the history of execution attempts assigned to a single, active thread.

List Threads

Provides an overview of all existing and currently active conversation threads.

Update Thread State

Allows a human to manually input data or override variables within an ongoing...

Security and governance baked right in.

Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.

Claude AI

Open Claude Settings

Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.

Add Custom Connector

Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:

https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp

Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. For OAuth-protected servers, expand Advanced settings to add credentials.

Start a conversation

Open a new chat. The LangGraph Cloud integration is available immediately — no restart needed.

Antigravity

Configure Agent Environment

Open your Antigravity agent's workspace configuration or mcp-servers.json file.

Bind the Endpoint

Add the Vinkius endpoint URL to your agent's MCP connections list:

"mcp_servers": {
  "langgraph-cloud-stateful-ai-agents": {
    "serverUrl": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
  }
}

Provide your secure token in place of [YOUR_TOKEN_HERE] to ensure your agent requests are authenticated.

Execute

Start your Antigravity session. The agent will autonomously discover and utilize the LangGraph Cloud tools with full Vinkius guardrails applied.

VS Code Copilot

⚡

One-Click Install (Recommended)

In your Vinkius Dashboard, simply click the Add to VS Code button for this server. We'll automatically configure your local workspace.

Or configure manually

Open MCP Settings

Open VS Code, press Ctrl/Cmd + Shift + P, and search for GitHub Copilot: MCP Servers.

Add Server Config

Add the Vinkius endpoint configuration to your mcp-servers.json file:

"langgraph-cloud-stateful-ai-agents": {
  "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
}

Ensure you replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.

LangChain

Install Dependencies

Install the LangChain MCP adapters for your environment:

pip install langchain-mcp-adapters

Connect the Server

Use the SSEClient in LangChain to connect to the Vinkius managed endpoint:

from langchain_mcp_adapters.client import SSEClient

# Connect to Vinkius
client = SSEClient(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
tools = client.get_tools()

CrewAI

Define the Tool

Load the Vinkius MCP tools into your CrewAI agents:

from crewai import Agent
from mcp_crewai import MCPTool

# Connect securely to Vinkius
vinkius_tools = MCPTool(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")

# Assign to Agent
researcher = Agent(
    role='Data Researcher',
    tools=vinkius_tools.get_all()
)

Execute Task

Run your CrewAI process. The agent will autonomously route tasks to the Vinkius managed server.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

Import from OpenAPI, Swagger, or YAML specs
Create Agent Skills with progressive disclosure
Deploy to edge with MCPFusion framework
Built in DLP, auth, and compliance on every call
Real time usage dashboard and cost metering
Publish to catalog or keep private

Start building

Make Your AI Do More

Start with LangGraph Cloud (Stateful AI Agents), then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.

Use this MCP plus 5,100+ others, all in one place
Add new capabilities to your AI anytime you want
Every connection is secured and compliant automatically
Track usage and costs across all your servers
Works with Claude, ChatGPT, Cursor, and more
New servers added to the catalog every week

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by LangGraph Cloud. 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.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

Your data is protected. See how we built it.

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This connection provides 10 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.

Debugging agent workflows used to be a black box.

Today, when an automated process fails, you're stuck clicking through dashboards. You check the main log view, then copy data into a secondary monitoring dashboard, and finally jump into the underlying API call logs. It's tedious; it involves three separate tabs and at least two copies-pasting sessions just to build a simple failure timeline.

With this MCP, you consolidate that entire process. You ask your agent client for the state of the run, and everything—the variables, the messages, the graph node where it stopped—is returned in one structured response. It's visibility on demand; no more jumping between services.

Controlling Agent Flow with `get_thread_state`

Before this MCP, if an agent failed mid-process, you could only see the last successful output. You couldn't tell if it was waiting for a specific piece of data, or if the internal reasoning path had missed a variable needed for the next step.

Now, `get_thread_state` gives you a complete snapshot—the graph state and all variables are available. That level of detail means you don't just know *that* it failed; you know exactly *why* and where to fix it.

Support 24/7 support@vinkius.com ↗

Security Vinkius Trust Center ↗

SLA Service Level Agreement ↗

Report Listing Send Report ↗

What your AI can actually do with this

Running advanced AI agents means dealing with complexity. When an agent has to make decisions based on multiple inputs—like reviewing a document and then drafting an email—it's not just one step; it's a whole graph of logic. This MCP lets you treat those complex workflows like a visible machine, allowing your agent client to monitor the entire process in real time.

You don’t have to assume things are working based on a simple success message. Instead, you can inspect every variable and see exactly where the workflow paused or stalled. If an agent needs human input before proceeding, this MCP lets you grab that state and perform manual overrides right from your chat interface.

It's about taking control of what runs in the background, giving you visibility into everything from managing assistant configurations to auditing scheduled background jobs, all managed through the Vinkius catalog.

Built · Hosted · Managed by Vinkius LangGraph Cloud MCP - Control Stateful AI Agents

Server ID 019d75c4-981e-7336-8e96-b24a21e7cd06

Vinkius Inspector

Compliance Grade A+

Score 100/100

Report View Report ↗

Who is this actually for?

This is for the platform engineer who can’t afford to have an agent fail silently; it's for anyone needing reliable debugging tools for mission-critical automation.

ML Platform Engineer

Debugging complex multi-agent workflows by using get_thread_state to pinpoint exactly which variable caused a graph traversal failure.

DevOps SRE

Auditing scheduled agent runs by checking the list of active jobs with list_crons, ensuring automated workflows fire when they should.

AI Solutions Architect

Managing multiple deployed assistant versions and testing new flows before production using list_assistants.

What Changes When You Connect

You stop guessing why an agent failed. By using get_thread_state, you retrieve the exact variable values and message history, letting you see precisely where the graph got stuck.

Debugging is immediate control. If a workflow gets into a dead state, you can use update_thread_state to manually inject data or force an override, moving the process forward without code changes.

You gain full visibility over background tasks. Check your automation schedule and audit runs using list_crons and list_runs, ensuring no scheduled job silently fails.

Managing multiple agents is easier. Use list_assistants to get a clean catalog of all deployed agent configurations, avoiding confusion between different versions or deployments.

You control the conversation's lifecycle. Need to start fresh? Use create_thread. Want to test the whole flow again? Start it with create_run.

See it in action

01 01

Debugging a Complex Multi-step Approval Process

The agent drafts a policy summary, but it hits a mandatory human review step. Instead of waiting for an email notification, you use the MCP to check the current state via get_thread_state, see that the variable 'Needs Approval' is set to true, and then manually override it using update_thread_state so the agent can proceed immediately.

02 02

Auditing an Automation Failure

The nightly inventory report failed. Instead of checking logs across three separate services, you use the MCP to check all scheduled jobs with list_crons, identify the failing job, and then review its history using list_runs to see what inputs caused the breakdown.

03 03

Handling a Stalled Sales Chatbot

A customer conversation thread stalls because an external API call times out. You use the MCP to grab the current state with get_thread_state, determine which piece of data is missing, and then manually inject that data using update_thread_state so the agent can resume its dialogue.

04 04

Comparing Agent Versions

You are deciding between two versions of your support bot. You use list_assistants to see both 'Support-V1' and 'Support-V2', then run a test case on each with create_run, allowing you to compare the actual execution paths side by side.

The honest tradeoffs

Assuming completion

Anti-pattern

The chat interface shows 'Run Started' and the user moves away, assuming the agent is working. Minutes later, nothing happens.

The Fix

Never rely on a simple start status. Always use get_run to check the actual status; if it stalls, manually inspect the state with get_thread_state before concluding it failed.

Ignoring scheduled tasks

Anti-pattern

The automated monthly summary never runs because the cron job was configured incorrectly or deleted without notice.

The Fix

Use list_crons to audit your schedule. If a job is missing, you can check the logs for past attempts using list_runs.

Over-relying on default state

Anti-pattern

An agent fails because it needs specific input (like a user ID) that wasn't provided in the initial prompt, and you have to restart everything.

The Fix

Use update_thread_state immediately after identifying the missing variable. Injecting the correct data manually is faster than restarting the entire flow.

When It Fits, When It Doesn't

You should use this MCP if your agent workflows are mission-critical and statefulness matters; that is, if failure or partial completion requires deep debugging access. For example, you need to confirm why an agent stopped using get_thread_state, or you must manually trigger a step using update_thread_state. Don't use this MCP if your goal is simple message passing or basic CRUD operations; for those needs, a simpler messaging tool will suffice. If you only need to list available agents, just use list_assistants—you don't need the whole control system.

Questions you might have

How do I check if my agents are running on a schedule using list_crons? +

You use list_crons to see every scheduled background job configured for your account. This tells you which agents run automatically and how often they fire.

What is the difference between create_run and get_run? +

You use create_run when you want to start a brand new execution with specific input data. You use get_run later to check on that run, getting its status and final output.

If I update_thread_state, does it affect the agent's history? +

Yes, updating the thread state manually injects data directly into the conversation memory. This means subsequent runs will see this new information as part of their context.

Can I list all available assistants using list_assistants? +

Absolutely. list_assistants gives you a clean directory of every compiled agent configuration, so you know exactly what tools are deployed in your LangGraph Cloud account.

If an agent gets stuck in a loop, how do I stop it using `cancel_run`? +

You interrupt the process by passing the run ID to cancel_run. This immediately terminates the graph execution. You can use this tool if you need to prevent resource waste or correct flawed logic mid-process.

What information does `list_threads` provide about my current conversations? +

list_threads shows all active thread IDs and their basic status. It's your primary way to monitor the existence of long-term memory buffers across your application, even if they haven't been actively used recently.

How can I use `list_runs` to audit a specific conversation thread? +

list_runs retrieves a chronological list of all execution attempts tied to one thread ID. This is crucial for auditing, letting you see if the agent tried multiple times or failed on previous runs.

What exact variables does `get_thread_state` return? +

get_thread_state returns the precise state graph and all associated variables at a given moment. It shows developers exactly which data inputs, or internal flags, are available for manual inspection or override.

Can I manually approve an agent's step using this server? +

Yes. Use the update_thread_state tool to perform manual node state overrides. This is the standard way to implement human-in-the-loop (HITL) patterns, allowing you to modify or approve graph variables directly mid-execution.

How do I see the current memory of a conversation thread? +

The get_thread_state tool retrieves the exact execution state of a thread, including all cyclical node variables and structured outputs stored in the cloud checkpoints. This gives your agent full visibility into the conversation history.

Can my agent trigger a new run on an existing thread? +

Absolutely. Use the create_run tool and provide the Thread ID, Assistant ID, and your new input payload. Your agent will fire the graph dynamically, allowing for multi-turn engagements within the same stateful boundary.

Connect to your AI in seconds.

List assistants

Cancel run

Create thread

LangGraph Cloud (Stateful AI Agents) with 10 Tools

Make your AI actually useful.

List Assistants

Cancel Run

Create Thread

Create Run

Get Run

Get Thread State

List Crons

List Runs

List Threads

Update Thread State

Security and governance baked right in.

Claude AI

Open Claude Settings

Add Custom Connector

Start a conversation

Claude Code

Open your terminal

Add the MCP Server

Start coding

Cursor

One-Click Install (Recommended)

Open Cursor Settings

Add New Server

Use in Composer

Antigravity

Configure Agent Environment

Bind the Endpoint

Execute

VS Code Copilot

One-Click Install (Recommended)

Open MCP Settings

Add Server Config

Windsurf

One-Click Install (Recommended)

Open Windsurf Settings

Add Server Endpoint

LangChain

Install Dependencies

Connect the Server

CrewAI

Define the Tool

Execute Task

Choose How to Get Started

Build Your Own

Make Your AI Do More

Works with Claude, ChatGPT, Cursor, and more

Debugging agent workflows used to be a black box.

Controlling Agent Flow with `get_thread_state`

What your AI can actually do with this

Here's how it actually works

Who is this actually for?

What Changes When You Connect

See it in action

Debugging a Complex Multi-step Approval Process

Auditing an Automation Failure

Handling a Stalled Sales Chatbot

Comparing Agent Versions

The honest tradeoffs

Assuming completion

Ignoring scheduled tasks

Over-relying on default state

When It Fits, When It Doesn't

Questions you might have