Deploy AI Agents From Terminal With LangGraph CLI Tutorial

LangSmith provides end-to-end tools for agent development and deployment, replacing the former LangGraph platform. It handles tracing (monitoring execution), evaluation (testing prompts), and deployment (exposing agents as APIs). The deployment workflow involves configuring langraph.json, setting up tracing projects, storing API keys as secrets, and creating deployments that automatically rebuild on code pushes. This produces API endpoints integratable with front-end frameworks, streamlining the path from local development to production deployment for agent applications.

This segment covers the complete workflow from local testing through production deployment and monitoring. Local testing involves running the LangGraph up command to start an API server, then using curl commands to verify agent functionality. After deployment, LangSmith provides visualization capabilities showing the agent's graph structure and execution paths in real-time. Users can observe tool calls, tool outputs, and final responses, with the ability to interrupt execution for debugging. Threads maintain conversation history for multi-turn interactions. The deployed agent exposes API endpoints for programmatic integration with custom interfaces. LangSmith provides comprehensive monitoring including LLM call success rates, trace success rates, latency, tokens per second, and tokens per trace, enabling deep inspection of individual threads for debugging and optimization.

LangSmith is a platform for debugging, testing, evaluating, and monitoring large language model applications, enabling users to log runs, create datasets for testing, and apply various evaluation metrics including criteria-based assessment (conciseness, relevance, correctness, harmfulness), QA evaluation with context and chain-of-thought reasoning, and distance metrics (embedding and string) to ensure LLM outputs remain valid as applications scale and evolve.

LangSmith is an observability platform that enables developers to trace, debug, and monitor AI agent execution by providing complete execution traces, token usage tracking, and detailed inspection of prompts, tool calls, and LLM responses, which is essential for debugging failures, optimizing prompts, and ensuring production-ready AI applications.

LangSmith is a tool for monitoring AI agents in production. It tracks: user inputs and agent outputs, response latency, token usage, and costs per query. It provides detailed traces showing the decision path the agent took, which tools were called, and the queries generated. This allows developers to validate that the agent is making correct decisions, identify errors in query generation, and understand the complete execution flow. The tool is essential for debugging and ensuring agent reliability in production environments.

This section demonstrates how to interact with deployed agents using the LangGraph server API. Key endpoints include creating threads (POST), getting thread state (GET), and running graphs with streaming (stream endpoint). The API is exposed to the internet without authentication on Render's free tier, requiring security measures like harder-to-guess URLs. Frontend integration involves creating threads with UUID-based IDs, streaming graph execution results, and retrieving the final state to render charts. The state includes messages (conversation history) and chart JSON (visualizations). Charts are rendered using Plotly's pio library from the JSON state. The complete workflow enables building fully featured AI applications.

The useStream hook enables seamless integration of LangGraph agents into React applications by providing features like state management, message streaming, interrupt handling, and branching, allowing developers to build interactive chatbots with features such as human-in-the-loop interruptions and conversation branching through checkpoint-based history management.

This tutorial demonstrates how to connect AI agents (LangChain and LangGraph) to client applications through API integration, covering two main approaches: using Agent Server (LangGraph Deploy) to expose agents as REST APIs and Server-Sent Events (SSE) streams, and wrapping agents with FastAPI to create custom backend gateways. The video shows practical examples of creating REST endpoints for synchronous agent interactions and streaming endpoints for real-time responses, enabling clients to communicate with agents through standard HTTP protocols.

A Multi-Agent Orchestrator System uses asynchronous event-driven architecture to manage stateful AI agent workflows without blocking the main API gateway, utilizing FastAPI as the API framework, Celery with Redis for task queuing, LangGraph for agent workflow orchestration, and PostgreSQL for persistent state logging, enabling real-time observability through WebSockets and human-in-the-loop validation at designated workflow nodes.

This section covers the complete deployment and client integration process for LangGraph Cloud applications. The deployment process involves connecting a GitHub account, selecting the repository, specifying the LangGraph JSON file path, adding a custom branch reference, selecting deployment type (development or production), and configuring environment variables (OpenAI API keys). After deployment, developers access the API URL and API key from the dashboard. The client uses the LangChain LangGraph SDK with the API URL and headers containing the API key. The stream events endpoint is wrapped in a runnable Lambda because the SDK doesn't directly provide streaming capabilities. Event handlers process streaming events, with developers only caring about onchain end events (node completion). Each handler maps backend results to UI components: generate filters maps to filter buttons, generate chart type renders loading components, generate data display format renders appropriate loading components, and filter data renders the final chart with display format title and description.

This segment demonstrates implementing agent capabilities through MCP services and continuous deployment. Developers define agent behaviors, test locally, and deploy to cloud via pull requests. Argo CD automatically updates cloud agents when PRs merge. The workflow enables rapid iteration, with agents tested against sample applications like streaming services with Swagger APIs. This demonstrates the complete cycle from development through deployment and iteration.

CI/CD pipelines automate the transition from development to production: (1) Commit ideal implementation code with best hyperparameters to version control (e.g., GitHub); (2) Trigger pipeline that deploys ephemeral agent in test environment; (3) Run evaluation on golden dataset using either remote Langfuse evaluators or local open-source frameworks like AutoEval or RAGAS; (4) If evaluation meets threshold, deploy to production; otherwise return to experimentation phase. This ensures production-ready agents undergo rigorous automated testing before deployment.

The pipeline pattern for agentic AI follows Build, Evaluate, Gate, Decision, Deploy. Build packages the agent, model version, prompt template, tool definitions, and configuration as a single versioned artifact—since prompt chains and tool definitions both change behavior, they must be versioned together. Evaluate runs the candidate against the golden dataset and red team agent, producing an evidence pack with evaluation reports, red team reports, content safety scans, and dependency checks. Gate decision compares scores against thresholds and checks for new red team findings or cost within budget. The strongest moment is the failure gate that stops a bad version before users see it. Three kinds of gates exist: PR gates (block bad prompts before merge, fast and lightweight), Deploy gates (block versions before next environment, full evaluation), and Watchdogs (scheduled checks against production to catch drift, failures, or upstream model changes). Each gate produces an artifact for the audit trail. Automating gates requires connecting the repo to Azure using OIDC for federated credentials instead of secrets in the repo, eliminating long-lived secrets and manual click operations.

AI agents automatically execute testing procedures, build processes, and deployment workflows. After implementing features, agents run tests, perform linting checks, and execute CI/CD pipelines including GitHub Actions. Upon successful completion, agents automatically create pull requests, trigger deployments to platforms like Vercel, and notify users when changes are merged and deployed to production. The agent handles the entire development lifecycle from feature implementation through production deployment, enabling end-to-end automation without manual intervention.

Continuous Integration and Continuous Delivery pipelines for microservices involve multiple validation stages before production deployment. Rappi's workflow includes code quality gates using SonarQube, security vulnerability scanning, automated testing (unit, integration, functional), and artifact repository management through Nexus or Artifactory. Jenkins orchestrates these processes, running tests and validations automatically. Quality gate approvals ensure only well-tested code reaches production. Tags enforce that production deployments must pass all quality checks. For production deployment, manual approval steps are required, particularly during business-critical hours, with VIPs or heads of engineering approving deployments during peak periods.