Andrew NguonlyandGitHub
3878addbe0
### Summary This is a large refactor of the content for the LangGraph Platform deployment options. Although there are a lot of changes, I do feel fairly confident that this is safe to merge and won't have any negative impact related to confusion around deployment options. However, please review thoroughly (i.e. run the docs locally). ### Goals and Non-Goals Just wanted to explicitly state goals and non-goals so that we're clear about what needs to be done now versus what can be done in a smaller follow-up PR. Goals 1. Add new content for the new deployment options (Self-Hosted Data Plane, Self-Hosted Control Plane). 1. Hide old content for deprecated deployment options (BYOC). 1. Create a pair of "conceptual" and "how-to" pages for each deployment option. As much as possible, the pages should have consistent headings. 1. Introduce the terms "control plane" and "data plane" and define them plainly without hiding/abstracting information. Non-Goals 1. Do not change the navigation of the existing deployment options. As much as possible, update content in-place or add new pages. Changing the navigation is a bigger task that can be done later. 1. Do not remove old content for deprecated deployment options. We may need to refer to this later. There are only ~2 pages (I think). ### Next Steps 1. Update the architecture diagrams for each deployment option. Commit Excalidraw file to source control. 1. Create a "how-to" page for the Control Plane UI. This page pertains to 3/4 deployment options. Most of the content lives in the "how-to" page for Cloud SaaS deployment. 1. Document required RBAC permissions for K8s for Self-Hosted Data Plane and Self-Hosted Control Plane (and update links). 1. Figure out how to consolidate plan information. 1. Figure out where to document licensing, telemetry, custom Postgres/Redis. 1. Update autoscaling content.
4.6 KiB
search
| search | ||
|---|---|---|
|
LangGraph Platform
Overview
LangGraph Platform is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework.
The LangGraph Platform consists of several components that work together to support the development, deployment, debugging, and monitoring of LangGraph applications:
- LangGraph Server: The server defines an opinionated API and architecture that incorporates best practices for deploying agentic applications, allowing you to focus on building your agent logic rather than developing server infrastructure.
- LangGraph Studio: LangGraph Studio is a specialized IDE that can connect to a LangGraph Server to enable visualization, interaction, and debugging of the application locally.
- LangGraph CLI: LangGraph CLI is a command-line interface that helps to interact with a local LangGraph
- Python/JS SDK: The Python/JS SDK provides a programmatic way to interact with deployed LangGraph Applications.
- Remote Graph: A RemoteGraph allows you to interact with any deployed LangGraph application as though it were running locally.
- LangGraph Control Plane: The LangGraph Control Plane refers to the Control Plane UI where users create and update LangGraph Servers and the Control Plane APIs that support the UI experience.
- LangGraph Data Plane: The LangGraph Data Plane refers to LangGraph Servers, the corresponding infrastructure for each server, and the "listener" application that continuously polls for updates from the LangGraph Control Plane.
The LangGraph Platform offers a few different deployment options described in the deployment options guide.
Why Use LangGraph Platform?
LangGraph Platform handles common issues that arise when deploying LLM applications to production, allowing you to focus on agent logic instead of managing server infrastructure.
-
Streaming Support: As agents grow more sophisticated, they often benefit from streaming both token outputs and intermediate states back to the user. Without this, users are left waiting for potentially long operations with no feedback. LangGraph Server provides multiple streaming modes optimized for various application needs.
-
Background Runs: For agents that take longer to process (e.g., hours), maintaining an open connection can be impractical. The LangGraph Server supports launching agent runs in the background and provides both polling endpoints and webhooks to monitor run status effectively.
-
Support for long runs: Vanilla server setups often encounter timeouts or disruptions when handling requests that take a long time to complete. LangGraph Server’s API provides robust support for these tasks by sending regular heartbeat signals, preventing unexpected connection closures during prolonged processes.
-
Handling Burstiness: Certain applications, especially those with real-time user interaction, may experience "bursty" request loads where numerous requests hit the server simultaneously. LangGraph Server includes a task queue, ensuring requests are handled consistently without loss, even under heavy loads.
-
Double Texting: In user-driven applications, it’s common for users to send multiple messages rapidly. This “double texting” can disrupt agent flows if not handled properly. LangGraph Server offers built-in strategies to address and manage such interactions.
-
Checkpointers and Memory Management: For agents needing persistence (e.g., conversation memory), deploying a robust storage solution can be complex. LangGraph Platform includes optimized checkpointers and a memory store, managing state across sessions without the need for custom solutions.
-
Human-in-the-loop Support: In many applications, users require a way to intervene in agent processes. LangGraph Server provides specialized endpoints for human-in-the-loop scenarios, simplifying the integration of manual oversight into agent workflows.
By using LangGraph Platform, you gain access to a robust, scalable deployment solution that mitigates these challenges, saving you the effort of implementing and maintaining them manually. This allows you to focus more on building effective agent behavior and less on solving deployment infrastructure issues.