Módulo 12: LangSmith y Producción

Introducción: De Prototipo a Producción

Descripción

Tu AI Research Assistant es un sistema multi-agente con planning automático, virtual filesystem, memoria persistente, supervisión humana, y Deep Agent capabilities. Lo construiste a lo largo de 11 módulos. Es, sin exageración, un sistema de producción.

Pero no puedes deployarlo todavía.

No porque esté incompleto. Sino porque no puedes responder cuatro preguntas que cualquier equipo de ingeniería te haría antes de poner un agente en producción:

¿Qué está haciendo mi agente? — En desarrollo, miras el terminal. En producción, tu agente corre 24/7. Nadie está mirando el terminal. Si el agente toma una decisión incorrecta a las 3am, ¿cómo lo sabes?
¿Cuánto está costando? — Una investigación que cuesta $0.12 es viable. Una que cuesta $4.80 destruye tu modelo de negocio. ¿Sabes cuánto cuesta cada ejecución? ¿Qué agente consume más tokens? ¿Qué operación es la más cara?
¿Dónde falla? — Tu agente procesa 200 consultas al día. 195 van bien. 5 producen respuestas malas. ¿Cuáles? ¿Por qué? ¿En qué paso exacto se desvió?
¿Sus respuestas son buenas? — "Parece que funciona" no es evaluación. ¿Las respuestas son relevantes? ¿Completas? ¿Exactas? ¿Cómo lo mides de forma sistemática, no anecdótica?

Este módulo te da las herramientas para responder las cuatro. LangSmith para tracing y debugging visual, evaluation automatizada con datasets y evaluators, y las prácticas de producción que transforman un prototipo en un sistema confiable.

Lo lograste. Ahora vamos a pulir lo que construiste para que esté listo para el mundo real.

¿Dónde estamos en la guía?

Este es el Módulo 12 de la guía LangChain & LangGraph: From Chains to Agents. Es el último módulo — el cierre del Bloque 4 (Producción) y de toda la guía.

Bloque 1: LangChain Core (Módulos 1-4)           ✅ Completado
Bloque 2: LangGraph Fundamentals (Módulos 5-7)   ✅ Completado
Bloque 3: LangGraph Avanzado (Módulos 8-10)      ✅ Completado
Bloque 4: Producción (Módulos 11-12)              ← ESTÁS AQUÍ (Módulo 12 — FINAL)

Tu progreso:

Bloque 1 — LangChain Core                   ✅ Completado
    │
    │  Módulo 1: Modelos y Proveedores       ✅
    │  Módulo 2: Tools y Tool Calling        ✅
    │  Módulo 3: Agents (create_agent)       ✅
    │  Módulo 4: Middleware y Customización   ✅
    │
    ▼
Bloque 2 — LangGraph Fundamentals           ✅ Completado
    │
    │  Módulo 5: Introducción a LangGraph    ✅
    │  Módulo 6: Functional API              ✅
    │  Módulo 7: Flujos Avanzados            ✅
    │
    ▼
Bloque 3 — LangGraph Avanzado               ✅ Completado
    │
    │  Módulo 8: Memoria y Persistencia      ✅
    │  Módulo 9: Human-in-the-Loop           ✅
    │  Módulo 10: Multi-Agent Systems        ✅
    │
    ▼
Bloque 4 — Producción                       ← ESTÁS AQUÍ
    │
    │  Módulo 11: Deep Agents                ✅ Completado
    │  Módulo 12: LangSmith y Producción     ← MÓDULO FINAL

Mira ese progreso. 11 módulos completados. Pasaste de invocar un modelo con una línea de código a construir un sistema multi-agente con planning automático, memoria persistente, y supervisión humana. Este módulo es el último paso: darle observabilidad y calidad medible a todo lo que construiste.

El puente desde el Módulo 11

Lo que ya tienes

Tu Research Agent v6 es un Deep Agent completo:

✅ Tres agentes especializados: researcher, analyst, writer
✅ Supervisor que coordina el flujo entre agentes
✅ Planning automático con write_todos
✅ Virtual filesystem para archivos intermedios
✅ Memoria persistente y multi-usuario con thread_id
✅ Approval gates antes de acciones costosas
✅ Retry con backoff exponencial y graceful degradation
✅ Búsqueda paralela en múltiples fuentes

La brecha de producción

Tu agente es técnicamente completo. Pero en producción, la situación cambia radicalmente:

En desarrollo:                          En producción:
  Tú miras el terminal                   Nadie mira nada
  Un usuario (tú)                        Cientos de usuarios
  Si falla, lo ves inmediatamente        Si falla, nadie lo detecta
  El costo no importa                    El costo es gasto operativo #1
  "Funciona en mi máquina"               "¿Funciona a las 3am del domingo?"
  Evalúas leyendo el output              Evalúas con métricas automatizadas

La mayoría de proyectos de AI no fallan porque el agente sea malo. Fallan porque no hay observabilidad. El agente produce una respuesta incorrecta, nadie lo detecta, los usuarios pierden confianza, y el proyecto se cancela. No por falta de capacidad técnica — por falta de monitoreo.

LangSmith: la plataforma de observabilidad

LangSmith es la plataforma de observabilidad para aplicaciones construidas con LangChain y LangGraph. Tres capacidades principales:

Tracing

Cada operación que tu agente realiza queda registrada: llamadas al modelo, ejecución de tools, cambios de estado, decisiones de routing. Todo en una línea temporal visual que puedes explorar paso a paso.

Sin tracing:
  Input: "Investiga AI en finanzas"
  Output: "Aquí está tu reporte..."
  ¿Qué pasó en el medio? 🤷

Con tracing:
  Input: "Investiga AI en finanzas"
  ├─ Supervisor → delega a Researcher
  │   ├─ web_search("AI fintech trends 2025") → 3 resultados, 1.2s, 450 tokens
  │   ├─ arxiv_search("AI financial systems") → 2 papers, 0.8s, 320 tokens
  │   └─ Return → researcher completó
  ├─ Supervisor → delega a Analyst
  │   ├─ gpt-4.1 → análisis de 5 fuentes, 2.1s, 1200 tokens
  │   └─ Return → analyst completó
  ├─ Supervisor → delega a Writer
  │   ├─ gpt-4.1-mini → reporte ejecutivo, 1.5s, 800 tokens
  │   └─ Return → writer completó
  └─ Output: "Aquí está tu reporte..."
     Total: 5.6s, 2770 tokens, $0.008

Evaluation

Medir la calidad de las respuestas de forma sistemática. No "¿se ve bien?" sino "¿cumple con criterios específicos de relevancia, completitud, exactitud, y formato?"

Monitoring

Dashboards con métricas de producción: latencia por operación, costo por ejecución, tasa de errores, distribución de scores de calidad.

El recorrido completo: de Módulo 1 a Módulo 12

Antes de entrar en el contenido técnico, mira lo que construiste:

Módulo 1:  model.invoke("¿Qué es AI?")
              Una línea. Un modelo. Una respuesta.

Módulo 2:  Modelo + tools. El agente puede HACER cosas.

Módulo 3:  create_agent: loop ReAct completo.

Módulo 4:  Middleware: customización y control del pipeline.

Módulo 5:  LangGraph: grafos de estado, nodos, edges.

Módulo 6:  Functional API: @entrypoint + @task.

Módulo 7:  Retry, branching, error handling, paralelismo.

Módulo 8:  Memoria: checkpointing, crash recovery, long-term memory.

Módulo 9:  Human-in-the-loop: approvals, review, feedback.

Módulo 10: Multi-agent: supervisor, handoffs, 3 agentes especializados.

Módulo 11: Deep Agents: planning automático, virtual filesystem.

Módulo 12: Observabilidad, evaluation, producción.
              ↑ ESTÁS AQUÍ

De una línea de código a un sistema multi-agente de producción con observabilidad completa. Eso es un AI Engineer.

Qué cambia en producción

Observabilidad = confianza

Sin tracing, deployar un agente es un acto de fe. "Creo que funciona bien. Espero que no se rompa." Con tracing, sabes exactamente qué hizo tu agente, cuánto costó, y dónde falló. La observabilidad te da confianza para deployar y dormir tranquilo.

Evaluation como práctica continua

No es algo que haces una vez al final. Es algo que ejecutas con cada cambio de prompt, cada actualización de modelo, cada nueva feature. Si cambias el system prompt del analyst, ¿mejoró o empeoró? Sin evaluation automatizada, estás adivinando.

Costos como constraint de diseño

Los tokens cuestan dinero. En desarrollo no importa — estás iterando. En producción, con 200 consultas diarias, la diferencia entre usar gpt-4.1 y gpt-4.1-mini para el researcher puede ser $50/día vs $5/día. Token tracking no es un nice-to-have — es una herramienta de negocio.

Mapa del módulo

#	Cápsula	Qué aprenderás	Tipo
01	Introducción (esta)	De prototipo a producción, LangSmith, el journey completo	Intro
02	Tracing y observabilidad	Setup de LangSmith, leer traces, identificar bottlenecks, custom metadata	Técnica
03	Debugging visual de agentes	Workflow de debugging con dashboard, comparar traces, errores	Técnica
04	Evaluation: datasets y evaluators	Crear datasets, evaluators específicos, LLM-as-judge, calibración	Técnica
05	Token tracking y cost control	UsageMetadataCallbackHandler, costo por operación, rate limiting	Técnica
06	Production checklist	Configuration management, error monitoring, deployment patterns	Técnica
07	Monitoring y dashboards	Métricas de producción, alertas, tendencias de calidad	Técnica
08	Proyecto: Research Assistant de producción	Research Agent v7: tracing + evaluation + cost control + production-ready	Proyecto

Flujo de aprendizaje

Empiezas con tracing (cápsula 02) — la base de toda observabilidad: ver qué hace tu agente paso a paso. Luego usas los traces para debugging visual (cápsula 03) — identificar y resolver problemas sin adivinar. Con observabilidad, implementas evaluation (cápsula 04) — medir la calidad de forma sistemática con datasets y evaluators. Agregas token tracking (cápsula 05) — visibilidad de costos y rate limiting para control de presupuesto. La cápsula 06 cubre el production checklist — todo lo que necesitas verificar antes de deploy. La cápsula 07 agrega monitoring — dashboards y alertas para producción continua. Finalmente, integras todo en el Research Agent v7 (cápsula 08).

La progresión es: tracing → debugging → evaluation → costos → checklist → monitoring → proyecto.

Conexión con el proyecto

Research Agent v7: production-ready

Tu Research Agent recibe su capa final:

v1 (Módulo 6):  Funcional pero frágil
    ↓
v2 (Módulo 7):  Robusto (retry, branching, error handling)
    ↓
v3 (Módulo 8):  Persistente (checkpointing, memoria, multi-usuario)
    ↓
v4 (Módulo 9):  Supervisado (approval gates, review, feedback)
    ↓
v5 (Módulo 10): Multi-agent (researcher + analyst + writer + supervisor)
    ↓
v6 (Módulo 11): Deep Agent (planning automático, virtual filesystem)
    ↓
v7 (Este módulo): Production-ready
    │
    │  📊 Tracing: cada paso visible en LangSmith
    │  🔍 Debugging: identificar fallos con un click
    │  📈 Evaluation: calidad medida con criterios específicos
    │  💰 Cost control: token tracking y rate limiting
    │  ✅ Production checklist: listo para deploy
    │
    ▼
    🚀 DEPLOYMENT

Al terminar este módulo, ejecutas una investigación completa y puedes: ver cada paso en LangSmith (qué buscó, qué analizó, qué escribió), medir la calidad del reporte con evaluators automatizados, saber exactamente cuánto costó en tokens, y verificar que cumple todos los criterios del production checklist. Eso es la diferencia entre "funciona en mi máquina" y "está listo para usuarios reales."

El antes y después

Para que dimensiones lo que lograste, mira la evolución de lo que puedes hacer con tu Research Assistant:

SIN este módulo (Módulo 11):
  - Ejecutas: agent.invoke({"query": "Investiga AI en finanzas"})
  - Obtienes: un reporte
  - Preguntas sin respuesta:
      ¿Cuánto costó? → No sé
      ¿Qué nodo fue el más lento? → No sé
      ¿Las respuestas son buenas? → Me parece que sí
      ¿Dónde falla? → No sé hasta que un usuario se queja

CON este módulo (Módulo 12):
  - Ejecutas: agent.invoke({"query": "Investiga AI en finanzas"})
  - Obtienes: un reporte
  - Preguntas respondidas:
      ¿Cuánto costó? → $0.12 (breakdown: researcher $0.04, analyst $0.05, writer $0.03)
      ¿Qué nodo fue el más lento? → search_web: 2.1s (65% del total)
      ¿Las respuestas son buenas? → Relevancia: 0.92, Completitud: 0.85, Accuracy: 0.88
      ¿Dónde falla? → 3 de 200 consultas tuvieron relevance < 0.5, todas sobre quantum computing

Esa es la diferencia entre un prototipo y un sistema de producción.

Qué NO cubre este módulo

❌ LangGraph Platform / Cloud — Deployment serverless con LangGraph Platform es un tema avanzado más allá del scope de esta guía. Mencionamos que existe como opción
❌ Infrastructure as Code — Terraform, Kubernetes, CI/CD pipelines. Son temas de DevOps que complementan este módulo pero no son específicos de AI
❌ A/B testing de prompts — Experiments en LangSmith son poderosos pero van más allá de la evaluación básica que cubrimos
❌ Custom dashboards — Usamos las dashboards built-in de LangSmith. Construir dashboards custom con Grafana/Datadog es un siguiente paso
❌ Security y compliance — PII detection, audit logging avanzado, y compliance regulatoria son temas que requieren su propio módulo

Setup técnico

Prerequisitos

✅ Módulo 11 completado — tienes un Research Agent v6 con Deep Agent capabilities
✅ Python 3.11+ instalado
✅ Al menos una API key de un proveedor (OpenAI recomendado)
✅ Cuenta de LangSmith — crea una en smith.langchain.com

Instalación

pip install langsmith langchain-openai langgraph python-dotenv

Verifica las importaciones:

import langsmith
from langsmith import Client

print(f"langsmith version: {langsmith.__version__}")
print(f"Client disponible: {Client is not None}")
# Output esperado:
# langsmith version: 0.3.x
# Client disponible: True

Variables de entorno

Agrega las variables de LangSmith a tu .env:

# .env
OPENAI_API_KEY=sk-...

# LangSmith
LANGSMITH_TRACING=true
LANGSMITH_API_KEY=lsv2_pt_...
LANGSMITH_PROJECT=research-assistant-prod

Tres variables:

LANGSMITH_TRACING=true — activa el tracing automático para todas las operaciones de LangChain/LangGraph
LANGSMITH_API_KEY — tu API key de LangSmith (obtenla en Settings → API Keys)
LANGSMITH_PROJECT — el nombre del proyecto donde se guardan los traces (se crea automáticamente)

Verificación rápida: primer trace

Ejecuta este script para verificar que el tracing funciona:

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

model = init_chat_model("openai:gpt-4.1-mini")

response = model.invoke("¿Qué es observabilidad en AI? Responde en una oración.")
print(f"Respuesta: {response.content}")
print(f"\n→ Abre LangSmith (smith.langchain.com) y busca este trace en tu proyecto.")
print(f"  Deberías ver: el input, el output, tokens usados, y latencia.")
# Output esperado:
# Respuesta: La observabilidad en AI es la capacidad de monitorear, entender y diagnosticar...
#
# → Abre LangSmith (smith.langchain.com) y busca este trace en tu proyecto.
#   Deberías ver: el input, el output, tokens usados, y latencia.

Si ves la respuesta del modelo y encuentras el trace en LangSmith, estás listo. Cada llamada a LangChain/LangGraph se traza automáticamente — sin cambiar una sola línea de tu código existente.

Evidencia de éxito

Al terminar este módulo, sabrás que tuviste éxito si:

✅ Configuras tracing con LangSmith e interpretas traces en el dashboard: identificas el nodo más lento, ves el prompt exacto que se envió, detectas tool calls redundantes
✅ Haces debugging visual: encuentras el paso exacto donde el agente se desvió, sin agregar print statements ni re-ejecutar
✅ Creas un dataset de evaluación con preguntas de referencia y criterios específicos (relevancia, completitud, accuracy, formatting)
✅ Implementas evaluators built-in y custom, incluyendo LLM-as-judge con calibración
✅ Trackeas token usage por operación y por agente, conectando costos con decisiones de negocio
✅ Tu Research Agent v7 tiene tracing, evaluation, cost control, y cumple el production checklist

Test de autoevaluación

Si puedes responder estas preguntas, vas por buen camino:

¿Qué diferencia hay entre mirar el terminal en desarrollo y tracing en producción?
Si tu agente produce una respuesta mala, ¿cómo encuentras el paso exacto donde se desvió usando LangSmith?
¿Por qué "¿es buena la respuesta?" no es un evaluator válido? ¿Qué criterios específicos usarías?
Si un LLM-as-judge dice que todas las respuestas son "excelentes", ¿qué haces?
Una investigación cuesta $0.45. ¿Cómo decides si es aceptable?

Resumen

La brecha de producción no es técnica — es de observabilidad. Tu agente funciona, pero sin tracing no sabes qué hace, sin evaluation no sabes si lo hace bien, y sin cost tracking no sabes cuánto cuesta. Este módulo cierra esas tres brechas
LangSmith es la plataforma de observabilidad para LangChain/LangGraph: tracing (ver cada paso), evaluation (medir calidad), monitoring (métricas de producción). Se activa con una variable de entorno: LANGSMITH_TRACING=true
Observabilidad = confianza. Sin ella, deployar un agente es un acto de fe. Con ella, sabes exactamente qué hizo, cuánto costó, y dónde falló
Evaluation es práctica continua, no un paso final. Se ejecuta con cada cambio de prompt, cada actualización de modelo, cada nueva feature
Los costos de tokens son gasto operativo #1 en aplicaciones con LLMs. Token tracking es una herramienta de negocio, no solo técnica
Este es el Módulo 12 de 12. Pasaste de model.invoke("hola") a un sistema multi-agente de producción con planning automático, memoria persistente, supervisión humana, y ahora observabilidad completa. Eso es un AI Engineer

Recursos adicionales

LangSmith Documentation — Documentación oficial completa de LangSmith: setup, tracing, evaluation, monitoring
LangSmith — Getting Started — Guía de inicio rápido para configurar tu primer proyecto
LangSmith Tracing Concepts — Conceptos de tracing: runs, traces, projects, metadata
LangSmith Evaluation — Framework de evaluación: datasets, evaluators, experiments
LangChain — Observability — Cómo configurar observabilidad en aplicaciones LangChain
The Production Gap in AI — LangChain Blog — Por qué la observabilidad es el missing piece en aplicaciones de AI

Módulo 12 — LangChain & LangGraph: From Chains to Agents

Siguiente cápsula: Tracing y Observabilidad — aprenderás cómo LangSmith registra automáticamente cada operación de tu agente, cómo leer traces para identificar bottlenecks y problemas, y cómo agregar metadata custom para filtrar y organizar traces en producción.

← AnteriorProyecto Evolutivo: Versión Deep Agent (v6)Siguiente →Tracing y Observabilidad