LangGraph Cloud MCP. Control the state of complex, multi-step AI agents.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
LangGraph Cloud (Stateful AI Agents) MCP Server lets you manage complex, multi-step AI workflows. You can list deployed assistants, create new conversation threads, and inspect the exact execution state of any graph run.
This is critical for debugging and controlling mission-critical, stateful agents.
What your AI agents can do
Cancel run
Interrupts and cancels an active, ongoing graph execution run.
Create run
Starts a new assistant run using a specific thread ID and input data.
Create thread
Initializes a new LangGraph thread to hold conversation and state history.
List all compiled LangGraph applications (assistants) ready to process stateful data.
Create and list conversation threads, maintaining long-term memory using cloud-managed checkpoints.
Get the status of a specific graph run and manually update the thread state to force a specific execution path.
List and track scheduled background jobs (Cron jobs) that automatically run agent workflows.
Retrieve detailed logs showing every step, function call, and internal reasoning path of a completed agent run.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
019d75c4cancel run
Interrupts and cancels an active, ongoing graph execution run.
019d75c4create run
Starts a new assistant run using a specific thread ID and input data.
019d75c4create thread
Initializes a new LangGraph thread to hold conversation and state history.
019d75c4get run
Retrieves the full status and details of a specific graph execution run.
019d75c4get thread state
Gets the exact state, including variables and messages, for a given conversation thread.
019d75c4list assistants
Lists all deployed LangGraph assistants, which are your compiled graph configurations.
019d75c4list crons
Lists all active scheduled cron jobs that run automated agent workflows.
019d75c4list runs
Lists all execution runs that have been assigned to a specific conversation thread.
019d75c4list threads
Lists all active LangGraph conversation threads.
019d75c4update thread state
Manually forces or updates the state graph variables of a thread, useful for human overrides.
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
Make Your AI Do More
Start with LangGraph Cloud (Stateful AI Agents), then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ 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
What you can do with this MCP connector
You're hookin' up your AI client to the LangGraph Cloud server. This lets you take total control of stateful, multi-step agents. You can manage the whole lifecycle of a complex agent run, making debugging and controlling mission-critical workflows a piece of cake. Here's what you can do:
Manage Deployed Agents
You'll get a list of all compiled LangGraph assistants using list_assistants, and you can also see all the automated agent workflows scheduled with list_crons.
Control Conversation Memory
To start, you can create a new conversation thread with create_thread and list all active threads with list_threads. You can then get the exact state, including variables and messages, for any given thread using get_thread_state or manually force or change the state graph variables with update_thread_state.
Monitor and Adjust Live Runs
When an agent is running, you can start a new run with specific inputs and a thread ID using create_run. You can check the status and full details of a specific run using get_run, and if something goes sideways, you can interrupt and cancel the active run with cancel_run.
You'll also see all runs assigned to a particular thread by calling list_runs.
Audit History and Paths
To see what happened, you can retrieve the full status and details of a completed run using get_run, or get a list of all runs associated with a thread using list_runs. You can view the detailed logs that show every step, function call, and the internal reasoning path of an agent's execution.
How LangGraph Cloud MCP Works
- 1 Subscribe to the LangGraph Cloud server and provide your API URL and API Key.
- 2 Use your AI client to call a listing tool (e.g.,
list_assistants) to see available graph configurations. - 3 Execute a workflow step (e.g.,
create_thread, followed bycreate_run) to start the process, and then useget_runorget_thread_stateto track the outcome.
The bottom line is, you control the entire lifecycle of your agent—from creation and scheduling to execution and manual state modification.
Who Is LangGraph Cloud MCP For?
This is for the platform engineer or the senior developer who has moved past simple, linear AI prompts. You need to debug complex, multi-step logic—the kind that fails halfway through and requires manual intervention. If your agents are mission-critical, you need this level of visibility and control.
Debugging stateful multi-turn agents and verifying that the graph traversal path hits every required node.
Monitoring deployed assistants and managing cloud-based checkpoints across multiple staging and production environments.
Auditing scheduled cron jobs and managing manual execution runs to guarantee automated AI workflows deliver reliably.
What Changes When You Connect
- Debugging State: Use
get_thread_stateto see the exact variables and messages a thread holds. This is essential when a multi-step agent fails and you need to know why it failed, not just that it failed. - Lifecycle Management:
list_assistantsshows you every deployed graph. You can then usecreate_runto test specific workflows without having to manually build a new chat thread every time. - Human Oversight: When an agent reaches a point needing human approval, use
update_thread_stateto manually inject the approval variable and force the agent to the next logical node. - Resource Control:
cancel_runstops runaway processes instantly. If a graph gets stuck in a loop or hits an unexpected state, you can kill the job and start fresh. - Automation Auditing:
list_cronslets you see what jobs run automatically (like daily reports). You can then uselist_runsto audit the status of the last automated execution. - History Tracking:
list_runsgives you a clear history of every execution tied to a thread ID, so you can track which version of the agent logic ran on which date.
Real-World Use Cases
Debugging a failed customer service flow
A customer's complex query fails halfway through the support agent's graph. Instead of guessing, your agent calls get_thread_state to inspect the variables. You see the required_info field is null, so you manually update_thread_state and feed the agent the missing ID, letting it complete the task.
Scheduling a daily compliance check
The compliance team needs the agent to run a full audit every night at 10 PM. You use list_crons to check the job status, then create_run to manually kick off an immediate test run to verify the cron job is configured correctly.
Validating a new agent version
Before deploying a new sales agent graph, you use list_assistants to check the existing versions. Then, you use create_run with a known payload to verify that the new graph structure handles edge cases before it hits production.
Stopping an runaway AI job
An agent gets stuck in an infinite loop trying to summarize a massive document. You catch it immediately by calling get_run to see the current status, and then use cancel_run to terminate the job and prevent resource exhaustion.
The Tradeoffs
Treating the agent like a simple chat box
Trying to solve a complex, multi-step workflow by just chatting with the agent, hoping it remembers everything. This fails because the agent's memory is volatile and doesn't track state transitions.
→
Always manage the state explicitly. First, create_thread to get a memory buffer. Then, use create_run to execute the graph. If it gets stuck, check the state with get_thread_state instead of just re-prompting.
Assuming a run is finished
Relying on the agent's conversational response to confirm completion. The agent might say it's done, but the underlying graph might still be running or waiting for an external webhook.
→
Always confirm the status. After initiating a run, immediately call get_run to verify the final status. Use list_runs to check the entire history if the status is ambiguous.
Bypassing manual checkpoints
Attempting to force the agent to skip a critical human review step just because you know the answer. The agent's logic will break because it expects the state variable to exist.
→
Use update_thread_state to manually inject the required variable (e.g., is_approved: true). This simulates the human action and allows the agent to proceed down the correct path.
When It Fits, When It Doesn't
Use this server if your AI agent logic requires more than a simple prompt-response cycle. If your workflow involves state—meaning the output of step A must feed into a specific, controlled input for step B—you need LangGraph Cloud. This is for agents that execute graphs. Don't use this if all you need is a single prompt to summarize a document; use a simple embedding or retrieval tool instead. If your primary need is just to see what's running, list_runs and list_threads give you visibility. If you need to fix a broken agent mid-process, you must use get_thread_state and update_thread_state. Don't try to build the state machine logic yourself; let the server enforce the rules.
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
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 server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Manually managing agent state is a nightmare.
Today, managing a multi-step agent means jumping between a chat interface, a separate logging dashboard, and a metrics panel. You copy the thread ID, paste it into the monitoring tool to see the current state, then copy the state variables, and finally, manually update the next step in a different UI. It's a mess of copy-pasting and context switching.
With this MCP server, you treat the entire process as a single API call. You can query the state with `get_thread_state` and, if necessary, force the next step using `update_thread_state`. You get full programmatic control over the agent's internal logic, eliminating the manual dashboard dance.
LangGraph Cloud MCP Server: Run and Control
Manual execution requires you to start a job, wait for confirmation, and then check the logs to see if the correct nodes fired. If the job fails, you're stuck. You can't tell if the failure was in the input or the graph logic.
Now, you start the job with `create_run`. If it gets into trouble, you can check `get_run` for the failure point, and if needed, `cancel_run` and restart with a corrected input payload. The control loop is immediate and precise.
Common Questions About LangGraph Cloud MCP
How do I see the memory or state of a conversation thread using get_thread_state? +
You pass the thread ID to get_thread_state. This returns the full state graph and all variables—including messages and structured outputs—that the LangGraph application has accumulated for that specific thread.
What is the difference between list_runs and list_threads? +
list_threads shows you all active conversation containers (the memory). list_runs shows the actual execution attempts (the actions) that happened within a specific thread container.
Can I manually fix an agent's path with update_thread_state? +
Yes. update_thread_state lets you bypass the natural flow and manually inject variables or change the state graph. This is necessary when you need a human-in-the-loop override.
How do I check if a background job is running? +
First, use list_crons to see the scheduled jobs. Then, use list_runs and get_run to track the execution attempts related to those automated jobs.
How do I use `list_assistants` to see what agent workflows are ready? +
The list_assistants tool shows all deployed LangGraph applications. This lets you see the compiled graph configurations available for stateful workloads.
What does `create_run` do when I need to test an agent with new data? +
create_run executes a specific assistant on a thread, accepting a payload. You use this when you need to test an agent with precise, new input data.
How can I stop a runaway agent using `cancel_run`? +
cancel_run sends an interrupt signal to an ongoing graph execution. It lets you halt a run immediately if the agent gets stuck or behaves incorrectly.
Do I need to use `create_thread` before calling `list_runs`? +
No, you use list_runs to see past executions for a thread ID. First, use create_thread to generate the ID you want to check.
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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
NVIDIA AI
Access LLMs, embeddings, code generation, and reasoning via NVIDIA API Catalog.
Replicate
Equip your AI to dynamically search, run, and monitor thousands of open-source machine learning models hosted on Replicate via simple text commands.
Google BigQuery
Empower your AI agent to query massive datasets via BigQuery — execute Standard SQL, track active jobs, and inspect table schemas natively.
You might also like
Google Ads
Equip your AI agent with direct access to Google Ads — manage search, display, and shopping campaigns, track conversions, and optimize ad spend without opening the Google Ads console.
GrabFood Partner
Automate GrabFood restaurant operations — manage orders, update menus, control store status, and run marketing campaigns directly from any AI agent.
MailerSend
Send transactional emails and manage domains via the MailerSend REST API.