Skill UI

This guide teaches how to build robust, production-grade ReAct agents using LangGraph 1.0's `create_react_agent`. It specifically addresses common agent failure modes, such as preventing infinite loops (recursion caps) and ensuring proper error propagation. Learn to define typed tools using Pydantic, manage state with checkpointers, and set precise recursion limits. Perfect for users migrating from legacy AgentExecutor or building reliable, multi-step tool-calling workflows.

This skill provides a comprehensive guide to building robust LangGraph 1.0 StateGraphs in Python. It covers defining typed TypedDict states with reducers, writing deterministic nodes, and defensively wiring conditional edges. It addresses common pitfalls such as silent graph termination, incorrect state updates using reducers, proper management of recursion limits, and handling evolving checkpoint schemas for reliable LLM workflow orchestration.

A comprehensive guide to ensuring robust state management for LangGraph agents. This skill addresses common checkpointing pitfalls (like missing thread_id or non-JSON serializable state) and details best practices for implementing reliable state persistence using MemorySaver or PostgresSaver. It covers thread discipline, schema migration, and time-travel debugging for production-ready applications.

Implement robust human-in-the-loop (HITL) approval gates for sophisticated LangGraph workflows. This skill enables the graph to pause execution before critical, irreversible actions (like sending emails or calling tools). It manages complex state serialization, provides clear resume semantics using `Command(resume=...)`, and integrates with external UIs (e.g., Slack) to await human decision, ensuring safe and controlled workflow execution.

This guide addresses critical LangGraph streaming pitfalls, including state overdraw, proxy buffering issues (Nginx, Cloud Run), and excessive event noise. It provides a production-grade pattern for implementing robust SSE/WebSocket endpoints using FastAPI. Learn how to correctly select the `stream_mode` (messages, updates, values) and implement server-side event filtering to reliably build live-token chat UIs and perform comprehensive state visualization.

Master advanced patterns for composing LangGraph subgraphs, which is essential for building robust, multi-agent systems like planner-executors or hierarchical teams. This skill addresses critical issues such as shared state contract propagation (P21) and callback scoping (P28). Learn to manage state across independent graph components using sophisticated dispatch patterns: compiled nodes, Send fan-out, and Command bubble-up.

This skill defines canonical, ordered middleware patterns for LangChain and LangGraph agents. It addresses critical production-level LLM deployment issues, including PII leakage across tenants, token budget overconsumption, prompt injection defense (Guardrails), and cache key corruption. Use this to build secure, scalable, and cost-aware AI applications.

A comprehensive guide to advanced, production-ready LLM inference using LangChain 1.0. This skill addresses common pitfalls and bugs when integrating multiple providers (Claude, GPT-4o, Gemini), covering issues like structured output reliability, correct streaming token accounting, and robust handling of complex AIMessage content blocks. It teaches best practices for model initialization, provider routing, and version-safe code implementation.

This skill integrates LangChain 1.0 and LangGraph 1.0 into standard OpenTelemetry (OTEL) backends (e.g., Jaeger, Honeycomb, Tempo). It solves critical observability gaps by ensuring correct prompt content capture, propagating spans across complex subgraphs, and providing five LLM-specific Service Level Objectives (SLOs) like latency and cost. Ideal for multi-tenant, compliance-sensitive, or existing OTEL stack environments where LangSmith is unsuitable.

This skill provides advanced techniques for robust prompt engineering within LangChain applications. It solves common production issues, such as f-string template breakage when user input contains literal curly braces, and guides developers on consolidating scattered prompts. Crucially, it details how to use the LangSmith Prompt Hub to version, pin, and A/B test prompts using immutable commit hashes, ensuring stable, reproducible LLM deployments.

This skill guides the design and optimization of production-grade multi-agent systems. It specializes in using LangGraph, LangChain, and DeepAgents to create structured, complex AI workflows. It covers state management, agent routing, memory integration, and tool calling, making it ideal for building robust, scalable agents like supervisors, planners, and coders.

This module provides a lazy adapter registry to seamlessly integrate OpenMed's clinical PII detection with major NLP frameworks like Microsoft Presidio, spaCy, and LangChain. It allows users to use OpenMed for enhanced PII recall, merge spans, or implement on-device PHI redaction guardrails without rewriting entire pipelines.