Skip to main content
skill CX Codex

langsmith-deployment — Claude Code skill: installation

This Claude Code skill manages agent server deployments in LangSmith Deployment. It comes into play when validating langgraph.json, changing revisions, or diagnosing runtime issues.

MIT ★ 106 updated 2026-11-11

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add soba-labs/langchain-agent-skills --skill langsmith-deployment -a claude-code
Open on GitHub

What langsmith-deployment does

The skill checks langgraph.json, helps select Cloud, Hybrid/Self-hosted with control plane, or Standalone, and guides deployment creation, revision updates, and rollbacks. Python and TypeScript scripts handle configuration checks and control-plane API calls. Another script produces a JSON monitoring plan; alerts themselves are set up in the LangSmith UI.

It also covers CI/CD wiring, environment variables, secrets, and post-deploy checks for status, health endpoints, traces, and metrics. Run the Python scripts with uv run python. The examples use LANGSMITH_API_KEY for API access; standalone servers require DATABASE_URI, REDIS_URI, a license key, and any application provider keys.

What it helps with

  • validate langgraph.json before deployment
  • choose a hosting model for a LangGraph app
  • create a revision or roll back a failed one
  • prepare CI/CD automation and a monitoring plan

Example prompts for the agent

  • Validate langgraph.json for Cloud and report compatibility issues.
  • Create a deployment revision from the main branch.
  • Generate a monitoring and alert plan for my-agent-prod.

How to install langsmith-deployment

1Skills CLI (Vercel)

npx skills add soba-labs/langchain-agent-skills --skill langsmith-deployment -a claude-code

2Manually: put the files in place

~/.claude/skills/langsmith-deployment/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/langsmith-deployment/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about langsmith-deployment

How do I install langsmith-deployment in Claude Code?

Run npx skills add soba-labs/langchain-agent-skills --skill langsmith-deployment -a claude-code. The skill file is at ~/.claude/skills/langsmith-deployment/SKILL.md.

What does langsmith-deployment do?

It guides LangGraph configuration checks and LangSmith deployments, including revision creation and rollback. It also covers CI/CD automation and monitoring setup.

What does langsmith-deployment need to run?

The scripts use uv run python, and API access uses LANGSMITH_API_KEY. A standalone server requires DATABASE_URI, REDIS_URI, a license key, and any application provider keys.

Source text

SKILL.md · MIT
---
name: langsmith-deployment
description: "Deploy and operate production agent servers with LangSmith Deployment. Use when work involves choosing Cloud vs Hybrid/Self-hosted-with-control-plane vs Standalone, preparing/validating langgraph.json, creating deployments or revisions, rolling back revisions, wiring CI/CD to control-plane APIs, configuring environment variables and secrets, setting monitoring/alerts/webhooks, or troubleshooting deployment/runtime/scaling issues for LangChain/LangGraph applications."
---

# LangSmith Deployment

Use this skill to deploy, revise, monitor, and troubleshoot LangGraph-based agents in LangSmith Deployment.

## Use This Skill When

- You need to deploy a new agent to LangSmith Cloud.
- You need to create a new deployment revision from Git changes or env changes.
- You need rollback guidance for a failing revision.
- You need to choose deployment model: Cloud, Hybrid/Self-hosted with control plane, or Standalone server.
- You need CI/CD automation using LangSmith Deployment control-plane APIs.
- You need monitoring and alert setup aligned with current LangSmith alert model.
- You need `langgraph.json` validation and deployment compatibility checks.

## Deployment Model Selection

| Model | Use when | Build/Source | Operates infra |
|---|---|---|---|
| Cloud | Fastest managed production path | GitHub repo via control plane | LangSmith |
| Hybrid/Self-hosted with control plane | You need private data plane + centralized deployment UI/API | Container image + control plane | You |
| Standalone server | You want direct Agent Server hosting without control plane | Containerized server | You |

## Core Workflow

1. Validate local deployment config.
2. Choose deployment model and endpoint strategy.
3. Create deployment or revision.
4. Configure environment variables and secrets correctly.
5. Configure monitoring and alerts.
6. Verify runtime behavior and keep rollback path ready.

## Script-First Commands

### 1) Validate `langgraph.json`

```bash
uv run python skills/langsmith-deployment/scripts/validate_deployment.py --config langgraph.json --target cloud
```

### 2) Create a Cloud deployment (US default)

```bash
uv run python skills/langsmith-deployment/scripts/deploy_to_langsmith.py \
  --name "my-agent-prod" \
  --owner my-org \
  --repo my-agent-repo \
  --branch main \
  --config langgraph.json
```

### 3) Create a Cloud deployment (EU)

```bash
uv run python skills/langsmith-deployment/scripts/deploy_to_langsmith.py \
  --name "my-agent-prod" \
  --owner my-org \
  --repo my-agent-repo \
  --region eu
```

### 4) Use a self-hosted control plane

```bash
uv run python skills/langsmith-deployment/scripts/deploy_to_langsmith.py \
  --name "my-agent-prod" \
  --owner my-org \
  --repo my-agent-repo \
  --control-plane-url https://<your-langsmith-host>/api-host
```

### 5) Create a revision for an existing deployment

```bash
uv run python skills/langsmith-deployment/scripts/deploy_to_langsmith.py \
  --name "my-agent-prod" \
  --owner my-org \
  --repo my-agent-repo \
  --deployment-id <deployment-id> \
  --branch main
```

### 6) Roll back deployment revision

```bash
uv run python skills/langsmith-deployment/scripts/rollback_deployment.py \
  --deployment-id <deployment-id> \
  --list-revisions

uv run python skills/langsmith-deployment/scripts/rollback_deployment.py \
  --deployment-id <deployment-id>
```

### 7) Generate monitoring + alert setup plan

```bash
uv run python skills/langsmith-deployment/scripts/setup_monitoring.py \
  --project my-agent-prod \
  --output-json /tmp/monitoring-plan.json
```

Note: `setup_monitoring.py` generates a docs-aligned setup plan/templates. Alerts are configured in LangSmith UI per project.

## Configuration Rules To Enforce

- `graphs` is required in `langgraph.json`.
- For Python projects, `dependencies` is required.
- For JS projects (`node_version` present), dependencies may be handled via `package.json`.
- `env` may be either a string path to an env file or an inline object map.
- `python_version` should be one of `3.11`, `3.12`, `3.13` when set.
- `pip_installer` should be one of `auto`, `pip`, `uv` when set.
- `node_version` currently documented for LangGraph.js as `20`.

## API/Endpoint Notes

- LangSmith Deployment control-plane API defaults are:
- US: `https://api.host.langchain.com`.
- EU: `https://eu.api.host.langchain.com`.
- Self-hosted control-plane base URL is typically `https://<host>/api-host`.
- For org-scoped API keys, include workspace/tenant id (`X-Tenant-Id`), exposed by scripts as `--tenant-id`.

## Secrets And Environment Guidance

- Never hardcode secrets in `langgraph.json` or source code.
- Prefer environment injection from deployment UI, Kubernetes Secrets, or cloud secret managers.
- Avoid passing secrets in shell arguments when possible; prefer `LANGSMITH_API_KEY` env var.
- In control-plane deployment flows, tracing auth env handling differs from standalone; rely on deployment model docs before overriding tracing/auth vars.
- For standalone server, ensure required runtime vars are present (`DATABASE_URI`, `REDIS_URI`, license key, and any app provider keys).

## Verification After Deploy

- Check deployment/revision status in LangSmith Deployments UI.
- Verify server API and health endpoints from deployment runtime (`/docs` etc.).
- Run a smoke invocation against your assistant/graph.
- Confirm traces, latency, and error metrics in Monitoring dashboards.

## References To Load By Task

- `references/deployment-guide.md`: Deployment model choice and end-to-end execution.
- `references/cicd-integration.md`: CI/CD stages, control-plane automation patterns, preview/prod strategy.
- `references/environment-management.md`: Env var sources, secrets patterns, standalone required vars.
- `references/monitoring-alerts.md`: Dashboards, alert model, webhook payload guidance.
- `references/scaling-configuration.md`: Scaling responsibilities by model and tuning knobs.
- `references/troubleshooting-deployment.md`: Failure triage and rollback strategy.

## Script Map

- `scripts/validate_deployment.py`: Validate `langgraph.json` and deployment readiness.
- `scripts/deploy_to_langsmith.py`: Create deployment or revision via control-plane API.
- `scripts/deploy_to_langsmith.ts`: TypeScript equivalent deploy/revision script.
- `scripts/rollback_deployment.py`: List and rollback revisions.
- `scripts/setup_monitoring.py`: Generate alert/dashboard/webhook setup plan.

## Assets

- `assets/templates/langgraph-cloud.json`: Cloud-oriented starter config.
- `assets/templates/github-actions-deploy.yml`: CI/CD template for deployment automation.
- `assets/templates/kubernetes-deployment.yaml`: Kubernetes template for self-managed environments.
- `assets/templates/.env.example`: Env var template for safe sharing.

© soba-labs · MIT · soba-labs/langchain-agent-skills

Similar skills

All skills for DevOps and infrastructure →
arize-migrate-langsmith arize arize-migrate-langsmith is a Claude Code skill that imports historical traces, datasets, and prompts from LangSmith into Arize AX. Runs when switching LLM observability platforms. CX Codex +1 416installs observability-langsmith Orchestra Research The observability-langsmith skill covers LangSmith tracing, evaluation, and monitoring for LLM applications. Use it to inspect runs, test model outputs, and watch production metrics. CX Codex +1 56installs model-deployment secondsky model-deployment — a skill for getting a trained model into production: FastAPI server, Docker, Kubernetes, monitoring and drift detection. Useful once the model works and serving does not. CX Codex +1 400installs langsmith-fetch langchain-ai langsmith-fetch — a skill that pulls LangSmith traces into your agent session for debugging tool calls, reviewing conversation history, and inspecting agent runs. Requires LANGSMITH_API_KEY in a .env file to connect. CX Codex +1 1,300installs langsmith-online-eval-engineering langchain-ai langsmith-online-eval-engineering is a Claude Code skill for connecting LangSmith online evaluators to traces and conversations. It supports run filters, sampling, and quality feedback. CX Codex +1 409installs langsmith akillness Routes LangSmith work into one workflow before touching the SDK. Use it when you need trace visibility, offline evaluation, annotation queues, prompt versioning, or cross-service lineage in LLM apps and agents. CX Codex +1 328installs

From the same set9

langsmith-trace-analyzer The langsmith-trace-analyzer Claude Code skill downloads and analyzes LangSmith traces. It helps investigate agent runs and compare evaluation results. CX Codex +1 ★ 106repo stars langgraph-testing-evaluation langgraph-testing-evaluation — a skill for Claude Code tests and evaluates LangGraph and LangChain agents. It supports test scaffolds, trajectory scoring, dataset runs, and version comparisons. CX Codex +1 ★ 106repo stars langgraph-state-management The langgraph-state-management Claude Code skill helps shape state schemas for LangGraph applications and diagnose update behavior. It applies to reducer design, persistence setup, and checkpoint debugging. CX Codex +1 ★ 106repo stars langgraph-project-setup The langgraph-project-setup Claude Code skill scaffolds and configures LangGraph projects. It activates for project structure, langgraph.json, provider variables, dependency setup, and configuration troubleshooting. CX Codex +1 ★ 106repo stars langgraph-error-handling The langgraph-error-handling Claude Code skill adds error-handling patterns to LangGraph. It applies to transient failures, model recovery, and workflows that need human approval. CX Codex +1 ★ 106repo stars langgraph-agent-patterns The langgraph-agent-patterns Claude Code skill helps build agent coordination patterns for LangGraph applications. It activates when choosing a pattern or debugging how agents work together. CX Codex +1 ★ 106repo stars deepagents-setup-configuration The deepagents-setup-configuration Claude Code skill scaffolds and checks Deep Agents projects in Python or JavaScript. It helps configure subagents, persistence, and human approval. CX Codex +1 ★ 106repo stars deepagents-planning-todos The deepagents-planning-todos Claude Code skill shows how to plan Deep Agents work with write_todos. It covers task breakdown, progress tracking, and diagnosing todos that remain unfinished. CX Codex +1 ★ 106repo stars

Project sponsors

Companies that keep this analytics open