LangChain ecosystem (LangSmith, LangGraph, LangServe)

Introduction

The LangChain ecosystem helps you build, test, and run language AI apps easily. It gives tools to track your work, visualize how your app thinks, and serve your app to users.

You want to keep track of how your language AI app performs and debug it.

You want to see a visual map of how your app processes language tasks step-by-step.

You want to quickly share your language AI app with others through an easy web interface.

You want to improve your app by analyzing past runs and data.

You want to build and deploy language AI apps without managing complex infrastructure.

Syntax

LangChain

from langsmith import Client as LangSmith
from langgraph.graph import StateGraph as LangGraph
from langserve import add_routes
from fastapi import FastAPI

# LangSmith for tracking
langsmith = LangSmith(api_key="your_api_key")

# LangGraph for building graphs
langgraph = LangGraph()

# LangServe for deployment
app = FastAPI()
add_routes(app, chain, path="/chain")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, port=8000)

LangSmith: Use the Client for tracing runs.

LangGraph: Build stateful multi-actor apps with graphs.

LangServe: Deploy chains as REST APIs using FastAPI.

Install with: pip install langsmith langgraph langserve fastapi uvicorn

Examples

Using @traceable decorator from LangSmith to automatically track function runs.

LangChain

from langsmith import traceable

@traceable
def my_function(input):
    return input.upper()

result = my_function("hello")

Building a simple LangGraph workflow.

LangChain

from langgraph.graph import StateGraph, END

graph = StateGraph(state_schema=dict)
graph.add_node("node", func)
graph.set_entry_point("node")
graph.add_edge("node", END)
app = graph.compile()

Deploying a LangChain runnable with LangServe.

LangChain

from langserve import add_routes
from fastapi import FastAPI
from langchain_core.prompts import ChatPromptTemplate

app = FastAPI()
chain = ChatPromptTemplate.from_template("Tell me about {topic}")
add_routes(app, chain, path="/template")
# Run with: uvicorn main:app --reload

Sample Program

Demonstrates traceable chain with LangSmith, simple LangGraph app. Note: Requires OPENAI_API_KEY and LANGCHAIN_API_KEY env vars for tracing. LangServe setup shown in syntax.

LangChain

from langsmith import traceable
from langgraph.graph import StateGraph, END
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

@traceable
class SimpleChain:
    def __init__(self):
        self.llm = ChatOpenAI(model_name="gpt-3.5-turbo")
        self.prompt = ChatPromptTemplate.from_template("Uppercase: {input}")
        self.chain = self.prompt | self.llm

    def run(self, input_text):
        return self.chain.invoke({"input": input_text}).content

# LangGraph example (simple)
graph = StateGraph(str)
graph.add_node("uppercase", lambda x: x.upper())
graph.set_entry_point("uppercase")
graph.add_edge("uppercase", END)
app = graph.compile()

simple_chain = SimpleChain()
input_text = "hello world"
output_text = simple_chain.run(input_text)
print(f"Input: {input_text}")
print(f"Output: {output_text}")
print(app.invoke("hello langgraph"))

Important Notes

LangSmith: Observability platform for tracing, testing, monitoring LLM apps.

LangGraph: Framework for building reliable, stateful AI agents with cycles, branching.

LangServe: Makes it easy to serve LangChain runnables as REST APIs.

All integrate seamlessly with core LangChain.

Summary

LangSmith: Tracing, datasets, evals for LLM apps.

LangGraph: Graphs for complex, cyclical agent workflows.

LangServe: Production-ready deployment of chains/runnables.

Practice

1. Which LangChain ecosystem tool is primarily used to track and log your language app runs?

easy

A. LangFlow

B. LangGraph

C. LangServe

D. LangSmith

Solution

1. Step 1: Understand the purpose of LangSmith and differentiate from other tools

   LangSmith is designed to track and log the execution of language applications, capturing run data. LangGraph visualizes app processes, and LangServe helps deploy apps, so they do not focus on logging.

2. Final Answer:

   LangSmith -> Option D

3. Quick Check:

   Tracking runs = LangSmith [OK]

Hint: Remember: Smith = logs and tracks runs [OK]

Common Mistakes:

• Confusing LangGraph with logging tool
• Thinking LangServe handles logging
• Assuming LangFlow is part of LangChain ecosystem

2. Which of the following is the correct way to start LangServe to deploy your app?

easy

A. langsmith deploy my_app.py

B. langserve start --app my_app.py

C. langgraph visualize my_app.py

D. serve langchain --run my_app.py

Solution

1. Step 1: Identify LangServe command syntax and eliminate incorrect commands

   LangServe uses the command langserve start --app <file> to deploy an app. Other options use wrong tool names or commands not related to LangServe.

2. Final Answer:

   langserve start --app my_app.py -> Option B

3. Quick Check:

   Deploy app = langserve start [OK]

Hint: Deploy apps with 'langserve start --app' command [OK]

Common Mistakes:

• Using langsmith or langgraph commands to deploy
• Mixing command order or flags
• Assuming 'serve langchain' is valid

3. Given this code snippet using LangGraph:

from langchain.tools import LangGraph
graph = LangGraph(app=my_app)
graph.show()

What will happen when graph.show() is called?

medium

A. It visually displays the language task flow of the app

B. It logs the app run details to LangSmith dashboard

C. It deploys the app to a server for sharing

D. It raises a syntax error due to missing parameters

Solution

1. Step 1: Understand LangGraph's role and analyze the code behavior

   LangGraph is used to visualize how language tasks flow in an app, showing a graphical representation. Calling graph.show() triggers the visual display of the app's task graph, not logging or deployment.

2. Final Answer:

   It visually displays the language task flow of the app -> Option A

3. Quick Check:

   graph.show() = visual flow display [OK]

Hint: LangGraph = visualize app flow, show() displays it [OK]

Common Mistakes:

• Confusing visualization with logging
• Thinking it deploys the app
• Assuming code has syntax errors

4. You wrote this code to deploy your app with LangServe:

import langserve
langserve.run('my_app.py')

But it raises an error. What is the likely cause?

medium

A. The method 'run' does not exist in LangServe; use 'start' instead

B. You must import LangSmith, not LangServe, to deploy apps

C. The filename must be a module, not a string

D. LangServe requires a config file, missing here

Solution

1. Step 1: Check LangServe API usage and confirm other options

   LangServe does not have a 'run' method; the correct command is 'start' to deploy apps. Importing LangSmith is unrelated to deployment, filename as string is valid, and config file is optional.

2. Final Answer:

   The method 'run' does not exist in LangServe; use 'start' instead -> Option A

3. Quick Check:

   Use 'start' method, not 'run' [OK]

Hint: LangServe uses 'start', not 'run' to deploy [OK]

Common Mistakes:

• Using 'run' instead of 'start'
• Confusing LangSmith with LangServe
• Thinking filename must be a module object

5. You want to build a language app that you can deploy, track, and visualize easily. Which sequence of LangChain ecosystem tools should you use?

hard

A. Use LangGraph to deploy, LangServe to track runs, and LangSmith to visualize flow

B. Use LangSmith to deploy, LangGraph to track runs, and LangServe to visualize flow

C. Use LangServe to deploy, LangSmith to track runs, and LangGraph to visualize flow

D. Use LangServe to track runs, LangGraph to deploy, and LangSmith to visualize flow

Solution

1. Step 1: Match each tool to its function and arrange tools in correct usage order

   LangServe deploys apps, LangSmith tracks and logs runs, LangGraph visualizes the app's task flow. First deploy with LangServe, then track runs with LangSmith, and visualize with LangGraph.

2. Final Answer:

   Use LangServe to deploy, LangSmith to track runs, and LangGraph to visualize flow -> Option C

3. Quick Check:

   Deploy, track, visualize = Serve, Smith, Graph [OK]

Hint: Deploy with Serve, track with Smith, visualize with Graph [OK]

Common Mistakes:

• Mixing up tool roles
• Using LangSmith for deployment
• Assuming LangGraph tracks runs