# LangGraph Cloud MCP > 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. ## Overview - **Category:** superpower - **Price:** Free - **Tags:** ai-agents, stateful-workflows, multi-turn-conversations, graph-based-ai, human-in-the-loop, agent-deployment ## Description 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. ## Tools ### 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 thread's state graph. ## Prompt Examples **Prompt:** ``` List all deployed assistants in my LangGraph Cloud account ``` **Response:** ``` I've found 3 assistants: 'Customer-Support-Bot' (ID: asst-123), 'Sales-Agent-V2' (ID: asst-456), and 'RAG-Search-Helper' (ID: asst-789). Which one would you like to create a new thread for? ``` **Prompt:** ``` Show me the current state for thread ID 'abc-123-xyz' ``` **Response:** ``` Retrieving state for thread 'abc-123-xyz'… The graph is currently at the 'human_review' node. Variables: 'is_approved' (null), 'final_answer' ('Initial draft generated...'). It is waiting for a manual override to proceed to the 'send_email' node. ``` **Prompt:** ``` List all active scheduled crons in my account ``` **Response:** ``` I've identified 2 active scheduled jobs: 1) 'Daily-Summary-Bot' (Runs every day at 9 AM UTC), 2) 'Inventory-Monitor' (Runs every 4 hours). Both are successfully triggering runs on their respective threads. Would you like to check the last run status for the summary bot? ``` ## Capabilities ### 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`. ## Use Cases ### 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. ### 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. ### 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. ### 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. ## Benefits - 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`. ## How It Works The bottom line is you gain a single chat interface that lets you query and manually manage complex, multi-stage AI workflows. 1. First, you subscribe to this MCP and provide your LangGraph API URL and key credentials. 2. Next, you interact with the system through your AI client—saying things like 'Show me the state for thread ABC' or 'List my active assistants.' 3. The MCP sends back structured data detailing the current agent status, allowing your client to report exactly what happened next. ## Frequently Asked Questions **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.