Coder Legion - Recent posts tagged langsmith

LangChain vs LangGraph vs LangSmith: Understanding the Ecosystem

Sat, 17 Jan 2026 13:36:52 +0000

Building LLM apps isn’t just about prompts anymore.
It’s about composition, orchestration, and observability.

TL;DR

LangChain provides the foundational building blocks for creating LLM applications through modular components and a unified interface for working with different AI providers.
LangGraph extends this foundation with stateful, graph-based orchestration for complex multi-agent workflows requiring loops, branching, and persistent state.
LangSmith completes the picture by offering observability, tracing, and evaluation tools for debugging and monitoring LLM applications in production.

Use:

LangChain for straightforward chains and RAG systems
LangGraph when you need sophisticated state management and agent coordination
LangSmith throughout development and production for visibility into behavior

Hands-on GitHub Repositories

LangChain RAG Project → https://github.com/rajkundalia/langchain-rag-project
LangGraph Analyzer → https://github.com/rajkundalia/langgraph-analyzer
LangSmith Learning → https://github.com/rajkundalia/langsmith-learning

Introduction

The landscape of LLM application development has evolved rapidly since 2022.

What began as simple prompt–response interactions has grown into multi-step workflows involving retrieval systems, tool usage, autonomous agents, and long-running processes. This evolution introduced new problems at each stage of the development lifecycle.

The composition problem → How do you connect prompts, models, tools, and data?
The orchestration problem → How do you manage branching, retries, loops, and shared state?
The observability problem → How do you debug, evaluate, and monitor these systems?

The LangChain ecosystem emerged to address each layer:

Problem	Tool	Year
Composition	LangChain	2022
Orchestration	LangGraph	2024
Observability	LangSmith	2023–2024

Each tool targets a specific layer in the LLM application stack.

LangChain: The Foundation

LangChain is the core framework for building LLM-powered applications.

Its primary goal is abstraction: different LLM providers expose different APIs, capabilities, and quirks. LangChain hides these differences behind a unified interface.

Core Building Blocks

LangChain is composed of modular, swappable components:

Prompts – Templates and structured inputs for models
Models – OpenAI, Anthropic, Google, or local LLMs
Memory – Conversation history and contextual state
Tools – Function calls to external systems
Retrievers – Vector databases and RAG pipelines

LCEL: LangChain Expression Language

What ties everything together is LCEL.

LCEL introduces a declarative, pipe-based syntax for composing chains:

prompt | model | output_parser

Instead of writing imperative glue code, you describe data flow.

Why LCEL Matters

LCEL enables:

Automatic async, streaming, and batch execution
Built-in LangSmith tracing
Parallel execution of independent steps
A unified Runnable interface (invoke, batch, stream)

This makes chains faster, cleaner, and easier to reason about.

Multi-Provider Support

LangChain supports dozens of LLM providers and integrations.

You can switch providers by changing one line of configuration, enabling:

Vendor independence
A/B testing across models
Cost and latency optimization

When LangChain Is Enough

Use LangChain when your workflow is primarily:

Input → Process → Output

Typical use cases include:

Chatbots with memory
RAG-based Q&A systems
Natural language → SQL generation
Linear tool pipelines

If your application doesn’t need complex branching or shared long-lived state, LangChain is the right tool.

LangGraph: Stateful Agent Orchestration

LangGraph solves the orchestration problem.

As soon as your application needs to:

make decisions,
loop,
retry,
or coordinate multiple agents, linear chains start to break down.

Graph-Based Architecture

LangGraph models your application as a directed graph:

Nodes → processing steps or agents
Edges → execution flow between nodes

This enables patterns that are hard or impossible with chains:

Loops and retries
Conditional branching
Parallel execution
Shared, persistent state

State as a First-Class Concept

Every LangGraph workflow operates on a shared state object.

Nodes receive the current state
They compute updates
Updates are merged back into state

This allows multiple agents to collaborate naturally.

Example:

Research agent gathers sources
Fact-checking agent validates claims
Synthesis agent produces the final answer

All without complex message passing.

Conditional Routing

LangGraph supports conditional edges.

A function decides which node runs next based on runtime state:

Route customer queries to specialist agents
Loop back when required information is missing
Retry until success conditions are met

Persistence & Checkpointing

LangGraph includes built-in checkpointing:

Persist state across restarts
Resume long-running workflows
Support human-in-the-loop pauses
Enable time-travel debugging

This is critical for production-grade agent systems.

Visualization Support

LangGraph workflows are inspectable and exportable:

Mermaid diagrams for documentation
PNG images for presentations
ASCII graphs for terminal debugging

This makes complex agent systems understandable and communicable.

When You Need LangGraph

Choose LangGraph when you need:

Explicit shared state
Runtime decision-making
Retry and failure recovery
Multi-agent coordination
Long-running workflows

A classic example is an autonomous research agent that iteratively searches, reads, verifies, and synthesizes information.

LangSmith: The Observability Layer

LangSmith answers the question:

“What is my LLM application actually doing?”

It doesn’t build workflows — it illuminates them.

Tracing Everything

LangSmith captures full execution traces:

Prompts and responses
Token usage and latency
Component call stacks
Errors and retries

You can drill down from:

a full workflow run
→ to a single LLM call.

This makes debugging dramatically easier.

Evaluation & Regression Testing

LangSmith allows you to:

Create evaluation datasets
Run structured tests
Track quality metrics
Compare prompts and models

This enables regression testing for LLM apps — a must-have for production systems.

Production Monitoring

In production, LangSmith tracks:

Response times
Error rates
Token and cost trends
Usage by workflow or user

Alerts help you catch issues early and optimize costs.

Framework-Agnostic

While LangSmith integrates seamlessly with LangChain and LangGraph, it’s not limited to them.

You can instrument any LLM application with LangSmith.

Quick Comparison

Tool	Solves	Use When
LangChain	Composition	Linear workflows, RAG, simple agents
LangGraph	Orchestration	Branching, loops, shared state, multi-agent
LangSmith	Observability	Debugging, evaluation, production monitoring

The Broader Ecosystem

LangFlow

LangFlow provides a visual, drag-and-drop interface for building LangChain workflows.

Great for prototyping
Helpful for non-technical collaboration
Often exported to code for production

Model Context Protocol (MCP)

MCP (by Anthropic) standardizes tool and resource access for LLMs.

Works at the tool/retriever layer
Complements LangChain and LangGraph
Reduces custom integration effort
Framework-agnostic

MCP does not replace orchestration tools — it enhances connectivity.

Conclusion

The LangChain ecosystem is layered, not competitive.

LangChain builds the core logic
LangGraph manages complex workflows
LangSmith makes everything observable

Most serious LLM applications will use more than one of these tools.

Start simple, add complexity only when needed, and never ship without observability.

LangSmith vs. Phoenix by Arize AI: Choosing the Right Tool for LLM Observability

Wed, 03 Sep 2025 11:28:17 +0000

As Large Language Models (LLMs) become widely used in real-world applications, developers need better ways to monitor, debug, and improve them. That’s where observability tools like LangSmith and Phoenix by Arize AI come in. Understanding and debugging LLM applications, from prompt engineering to model outputs, requires specialized platforms. Two prominent players in this space are LangSmith by LangChain and Phoenix by Arize AI. While both aim to provide observability for LLMs, they cater to slightly different needs and offer distinct features. This article will delve into the purpose, features, installation, and code examples of both tools, helping you determine which is best suited for your specific LLM project.

1. Purpose:

LangSmith: Best suited for developers building with LangChain, as it helps trace, debug, and optimize chains and agents step by step.**. It acts as a centralized hub to visualize, understand, and improve the performance of complex LLM workflows built using the LangChain framework. LangSmith is deeply integrated with LangChain, making it a natural choice for developers already invested in this ecosystem. It emphasizes end-to-end tracing of LangChain components, from prompt templates to final outputs.

Phoenix by Arize AI: Covers a wider range of observability needs — from monitoring model accuracy and performance to detecting bias and data quality issues — for any LLM, not just LangChain.**. While it can be integrated with LangChain, it’s not limited to it. Phoenix provides a more holistic view of your LLM application, focusing on understanding model behavior in production and identifying potential issues related to data drift, prompt quality, and fairness. It aims to provide insights into model performance metrics and data distributions.

2. Features:

While both tools fall under the category of AI observability platforms, their strengths are different:

LangSmith focuses on tracing and debugging LangChain workflows. It includes a prompt playground, run tracing, dataset management, and team collaboration tools. It is tightly integrated into the LangChain ecosystem, requiring little setup.
Phoenix provides a wider set of observability features. It offers performance monitoring (latency, accuracy, cost), data drift detection, embedding visualization, and bias analysis. This makes it especially useful for teams that care about fairness, data quality, and large-scale monitoring across different LLMs.
1. Installation:

LangSmith:

pip install langchain
pip install langsmith

After installation, you’ll need to set your LangSmith API key as an environment variable:

export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="YOUR_LANGSMITH_API_KEY"
export LANGCHAIN_ENDPOINT="https://api.smith.langchain.com"
export LANGCHAIN_PROJECT="your-project-name" # Optional: If you want to use a specific project

Phoenix by Arize AI:

pip install phoenix

pip install phoenix

No API key is strictly required for local development, but you’ll need one for using Arize AI’s cloud platform.

Code Examples:

LangSmith:

       from langchain.llms import OpenAI
    from langchain.chains import LLMChain
    from langchain.prompts import PromptTemplate

template = """Question: {question}

Answer: Let's think step by step."""

prompt = PromptTemplate(template=template, input_variables=["question"])

llm = OpenAI(temperature=0)

llm_chain = LLMChain(prompt=prompt, llm=llm)

question = "What is capital of France?"

print(llm_chain.run(question))

By setting the environment variables as shown in the installation section, LangSmith will automatically trace the execution of this LangChain chain. You can then view the trace in the LangSmith UI.

Phoenix by Arize AI:

    import phoenix as px
import pandas as pd
import numpy as np

# Create some dummy data
data = {
    "prompt": ["Translate to French: Hello", "What is the capital of Germany?"],
    "response": ["Bonjour", "Berlin"],
    "latency": [0.5, 0.7],
    "sentiment": [0.8, 0.9],
    "embedding": [np.random.rand(128), np.random.rand(128)]
}
df = pd.DataFrame(data)

# Start Phoenix
session = px.launch_app()

# Log the data to Phoenix
px.log(df, session=session, embeddings_column_names={'embedding': 'embedding_column_name'})

This code logs a DataFrame containing prompts, responses, latencies, sentiment scores, and embeddings to Phoenix. You can then use the Phoenix UI to explore this data, visualize the embeddings, and analyze model performance. You can then view the data in the Phoenix UI running in your browser at the URL outputted by px.launch_app().

5. Choosing the Right Tool:

Choose LangSmith if:

You are heavily invested in the LangChain ecosystem.
Your primary need is to debug and trace complex LangChain chains and agents.
You want detailed visibility into the inner workings of your LangChain
workflows.
Choose Phoenix by Arize AI if: You need broader LLM observability, including model performance monitoring, data quality assessment, and bias detection.
You are working with various LLM frameworks or custom models. You need tools for identifying data drift and biases in your LLM applications.
You need to visualize embeddings and understand the semantic space of your data.

Conclusion:

Both LangSmith and Phoenix help you understand and improve LLMs but they serve different purposes. LangSmith is best for developers deep in LangChain workflows, while Phoenix is ideal for teams needing a full picture of LLM performance, fairness, and data quality in production. LangSmith excels at tracing and debugging LangChain chains, while Phoenix offers a broader view of LLM performance and data quality. Understanding their strengths and weaknesses will help you choose the right tool for your specific LLM project and ensure its success in production. Consider evaluating both tools with a small proof-of-concept to determine which best fits your team’s workflow and requirements.