LangGraph Agent Toolkit

Serve LangGraph agents through an authenticated HTTP API. Add streaming, persistent conversation history, managed model connections, and optional tools and observability. Use your own client or the included Streamlit interface.

Start here

• Follow Run your first agent to run a local API without a model key.

• Follow Application Onboarding to integrate the toolkit into an application.

• Use Choose an agent integration to choose an agent pattern and tool integration.

• Read Migrate to the current release before upgrading an existing deployment to 0.10.2.

• Use Deployment and Recovery and Connections and High Traffic to configure a deployed service.

The toolkit supports Python 3.11–3.14. Optional extras select providers, observability SDKs, MCP tools, Deep Agents, and the UI. See Installation Options.

Memory has two scopes. thread_id identifies short-term conversation state. user_id identifies the user scope for long-term stores. Passing a user ID does not create a store. See Usage Guide and Choose an agent integration for the contracts.

The running service exposes its HTTP schema at /docs and /openapi.json. The generated reference below describes the Python package.

Start and configure

• Run your first agent
  • Prepare a fresh checkout
  • Start and call the API
  • Stream and read history
  • Use the Python client
  • Add the optional UI
  • Select a real model or another agent
• Application Onboarding
  • 1. Define the application integration
  • 2. Install and lock the required dependencies
  • 3. Register agents and define resource ownership
  • 4. Set identity and memory contracts
  • 5. Connect the application client
  • 6. Verify the application before production
  • 7. Upgrade existing data and release
• Installation Options
  • Provider and Backend Extras
  • Agent Integrations
  • UI and Development Server
  • Minimal Frontend from Source
  • Development and Deployment
• Environment Setup
  • Configuration sources
  • Authentication and identity
  • Model providers
  • Named model configurations
  • Tool selection
  • Persistence
  • Observability
  • Optional Compose services
• Usage Guide
  • Connect to a running service
  • Authentication and memory identity
  • Call the HTTP API
  • Use the synchronous client
  • Stream responses
  • List saved conversations
  • Read and change history
  • Interpret metadata and failures
  • Resume a conversation in the UI
  • Register a custom agent
  • Resume a typed interrupt

Agents and integrations

• Choose an agent integration
  • Agent patterns
  • Concrete use cases
  • MCP and direct tools
  • Memory and persistence
  • Choose an observability backend
  • Observe and test the selected combination
• MCP tools
  • Install
  • Configure an HTTP server
  • Configure a local process
  • Select agents and settings
  • Resume a request for user input
  • Read tool-result metadata
  • Add MCP tools to a custom agent
  • Verify a deployment
• Optional tool selection
  • Select a mode
  • Configure an API worker
  • Use a separate selector model
  • Use the Python builders
  • Keep Deep Agents control tools available
  • Handle failures and permissions
  • Evaluate multi-turn behavior and cost
  • Run the offline example
  • Run the API benchmark
• Deep Agents
  • Install
  • Run the example
  • Use the HTTP service
  • Select tools for large catalogs
  • What it adds
  • Read documents and media
  • Offload binary content
  • Add tools and subagents
  • Configure skills, memory, and file permissions
  • Run background subagents
  • Advantages and tradeoffs
  • Memory boundaries
  • Tools and permissions
  • Operate long tasks
• Langfuse compatibility
  • Supported combinations
  • Installation
  • Adapter behavior
  • Verification and server upgrades
  • SDK v5 migration limits
  • Reviewed SDK releases
  • Delivery limits
  • Telemetry session identity
  • Shutdown batching limits
• Langfuse service upgrade
  • Select the Compose server version
  • Infrastructure and existing data
  • Run a disposable service test
  • Verification record
  • Compare synthetic records during a test upgrade
• Phoenix observability
  • Install and select the backend
  • Trace behavior
  • Prompt management
  • Feedback
  • Trace content and access
  • Self-hosted storage
  • Verification and limits

Deploy and upgrade

• Deployment and Recovery
  • API Image and Model Transport
  • Production Image Builds
  • Startup and Worker Supervision
  • PostgreSQL Connection Budget
  • Conversation Ordering
  • Failure and Retry Boundaries
  • Nested Calls and Shutdown
  • Client and Azure Resource Cleanup
  • Select the Langfuse SDK in an API image
• Connections and High Traffic
  • Choose Deployment Limits
  • Checkpoint Persistence
  • Request Admission
  • Repeated Requests for One Conversation
  • Managed OpenAI and Azure Connections
  • Database Fault Handling
  • Memory Coordination and Library Responsibilities
  • Capacity Planning and Verification
• Migrate to the current release
  • Refresh installation tools and images
  • Handle typed configuration secrets
  • Keep the two memory types separate
  • Choose an authentication mode
  • Authorize feedback from token users
  • Update clients and process configuration
  • Add conversation discovery
  • Review MCP clients
  • Review Deep Agents document inputs
  • Review typed interrupts and filesystem permissions
  • Check existing persistence
  • Prepare the migration
  • Preview and apply
  • Remove inactive conversation history
  • Provider messages and stream completion
  • Select the Langfuse SDK before upgrading
  • Check Langfuse trace URLs and session identity
• Dependency update review
  • CA security follow-up: 2026-10-28
  • Current baseline: 2026-10-27
  • Langfuse follow-up
  • Verification on 2026-10-27
  • Historical reviews
  • Changes that affect this package
  • Install and verify
  • Python 3.14 and CI follow-up
• October 2026 dependency releases
  • Deep Agents
  • LangChain
  • LangChain Core
  • OpenAI integration
  • Anthropic integration
  • AWS integration
  • Google integrations
  • LangSmith SDK
  • FastMCP
  • MCP SDK
  • Integration decisions
  • LangGraph
  • Checkpoint packages
  • LangGraph SDK
  • LangGraph CLI
  • Checkpoint upgrade operations
  • Legacy chains and text splitters
  • Optional Studio server and runtime
• Related projects and source review
  • Projects reviewed
  • Requested Agent Service Toolkit commits
  • Corrections from this review
  • Recommended next work

Python API reference

• API Reference
  • langgraph_agent_toolkit package

Develop and verify

• Contributing
• Testing
• API load tests
• Local pressure-test results: 2026-09-12
• Real LLM verification

Indices

• Index

• Module Index

• Search Page