langgraph-azure

Overview

langgraph-azure is a first-party deployment toolkit that bridges LangGraph with Azure AI Foundry, providing managed infrastructure for production LangGraph deployments. Released following Microsoft's acquisition of LangChain AI's parent company, it offers pre-built Azure integrations for storage, state persistence, model serving, and monitoring.

The toolkit handles the operational complexity of running stateful agent graphs at scale — auto-scaling workers, checkpoint persistence, and cost attribution — while maintaining full compatibility with the open-source LangGraph API. It is positioned as the enterprise deployment path for organizations standardizing on both Azure and LangGraph.

Features

• Managed LangGraph deployment on Azure AI Foundry
• Auto-scaling worker pools for graph execution
• Checkpoint persistence with Azure Cosmos DB
• Seamless Azure OpenAI model integration
• Built-in monitoring with Azure Monitor and Application Insights
• RBAC and Azure AD authentication
• Private endpoint support for VNet isolation
• Cost attribution and usage analytics per agent
• CI/CD integration with Azure DevOps and GitHub Actions

Installation

pip install langgraph-azure

Prerequisites:

• Azure subscription with AI Foundry enabled
• Azure OpenAI resource provisioned
• azure-cli installed and authenticated

az login
az account set --subscription <your-subscription-id>

Quick Start

from langgraph_azure import AzureGraphDeployment

# Create deployment configuration
deployment = AzureGraphDeployment(
    resource_group="my-rg",
    location="eastus",
    openai_deployment="gpt-4o",
    cosmos_db_account="my-cosmos",
    cosmos_db_database="langgraph",
    auto_scale={
        "min_replicas": 2,
        "max_replicas": 20,
        "scale_metric": "concurrent_graph_runs"
    }
)

# Deploy your LangGraph
from langgraph import Graph
graph = build_my_agent_graph()  # your existing LangGraph code

deployment.deploy(graph, name="customer-support-agent")

# Invoke the deployed graph
result = deployment.invoke({
    "input": "I need help with my order",
    "user_id": "user-123"
})
print(result["output"])

Core Concepts

Managed Graph Workers

Azure Graph Workers are auto-scaled compute instances that execute LangGraph runs. Each worker handles concurrent graph executions and can be scaled independently based on load.

Property	Description
min_replicas	Minimum number of always-on workers
max_replicas	Maximum workers during peak load
scale_metric	Auto-scaling trigger (concurrent runs, CPU, memory)
cooldown_period	Seconds between scale-up events

Checkpoint Persistence

Graph state checkpoints are stored in Azure Cosmos DB with automatic partitioning by thread ID. This enables:

• Resume from interruption: Graphs can resume from their last checkpoint
• Time-travel debugging: Replay any historical graph state
• Multi-tenant isolation: Each thread has isolated checkpoint state

Cost Attribution

Each graph invocation is tagged with cost metadata, enabling:

# Get cost breakdown per agent
costs = deployment.get_costs(
    agent_id="customer-support-agent",
    period="2026-08-01/2026-08-20"
)
print(costs)
# {
#   "total": 2847.32,
#   "by_model": {"gpt-4o": 2103.45, "gpt-3.5-turbo": 743.87},
#   "by_step": {"research": 1200.00, "synthesis": 900.00, "review": 747.32},
#   "total_tokens_input": 52_000_000,
#   "total_tokens_output": 18_500_000
# }

Advanced Features

VNet Isolation and Private Endpoints

deployment = AzureGraphDeployment(
    # ... other config
    network={
        "vnet_name": "agents-vnet",
        "subnet_name": "agent-subnet",
        "private_endpoints": {
            "cosmos_db": True,
            "openai": True,
            "storage": True
        }
    }
)

Azure AD Authentication

from azure.identity import DefaultAzureCredential

deployment = AzureGraphDeployment(
    # ... other config
    auth={
        "credential": DefaultAzureCredential(),
        "allowed_principals": [
            "app:customer-portal",
            "app:internal-tools"
        ]
    }
)

CI/CD Pipeline (Azure DevOps)

# azure-pipelines.yml
trigger:
  branches:
    include:
      - main

pool:
  vmImage: 'ubuntu-latest'

steps:
  - task: UsePythonVersion@0
    inputs:
      versionSpec: '3.12'

  - script: pip install langgraph-azure
    displayName: 'Install langgraph-azure'

  - task: AzureCLI@2
    inputs:
      azureSubscription: '$(AzureSubscription)'
      scriptType: 'bash'
      scriptLocation: 'inline'
      inlineScript: |
        python deploy_graph.py \
          --resource-group $(ResourceGroup) \
          --environment $(Environment) \
          --graph-path ./graphs/customer_support.py

Examples

Multi-Agent Customer Support System

from langgraph_azure import AzureGraphDeployment
from langgraph import Graph, StateGraph

# Build the graph (standard LangGraph code)
graph = StateGraph(AnalysisState)

graph.add_node("triage", triage_agent)
graph.add_node("research", research_agent)
graph.add_node("respond", response_agent)
graph.add_node("escalate", escalation_agent)

graph.set_entry_point("triage")
graph.add_edge("triage", "research")
graph.add_conditional_edges("research", route_to_response_or_escalation)
graph.add_edge("respond", "___end__")
graph.add_edge("escalate", "___end__")

app = graph.compile()

# Deploy to Azure
deployment = AzureGraphDeployment(
    resource_group="support-rg",
    location="eastus",
    openai_deployment="gpt-4o",
    cosmos_db_account="support-cosmos",
    auto_scale={"min_replicas": 3, "max_replicas": 50},
    monitoring={"log_level": "info", "sampling_rate": 0.1}
)

deployment.deploy(app, name="customer-support-v2")

Pros

• First-party Microsoft support with SLA guarantees
• Zero-config Azure deployment from existing LangGraph code
• Enterprise-grade security (RBAC, VNet, private endpoints)
• Native Azure OpenAI integration avoids model routing overhead
• Production-ready auto-scaling and monitoring
• Cost attribution simplifies budget management for multi-agent systems
• CI/CD integration with Azure DevOps and GitHub Actions

Cons

• Azure-only — no multi-cloud or on-premises deployment
• Microsoft ecosystem lock-in after deployment
• New project with limited production track record
• Pricing can be unpredictable at very high throughput
• Requires Azure subscription management overhead
• Cosmos DB checkpoint storage costs can add up for high-state graphs

When to Use

Use langgraph-azure when:

• Your organization is standardized on Microsoft Azure
• You need enterprise compliance (SOC 2, HIPAA, FedRAMP)
• You require auto-scaling for variable agent workloads
• You need cost attribution per agent or per department
• You want managed infrastructure without self-hosting complexity

Avoid if:

• You need multi-cloud deployment
• You are not an Azure customer
• Your agent workloads are small enough to self-host
• You need on-premises deployment

Resources

• GitHub Repository
• Azure Documentation
• LangGraph Documentation
• Azure AI Foundry