Artificial intelligence is advancing rapidly. Every week, new tools appear that make it easier to build apps powered by major language models.
But many beginners still get stuck on one question: How do you structure the logic of an AI application? How do you cleanly integrate pointers, memory, tools, and APIs?
This is where popular open source frameworks come in Lingchen And Lang Graf come in
Both are part of the same ecosystem, and they’re designed to help you build complex AI workflows without reinventing the wheel.
Langchain focuses on sequences of steps called chains, while Langgraph takes things a step further by adding memory, branching, and feedback loops to make your AI more intelligent and flexible.
This guide will help you understand what these tools do, how they differ, and how you can start using them to build your own AI projects.
What we will cover
What is Lingchen?
Lingchen is a Python and JavaScript framework that helps you build language model-driven applications. It provides a framework for combining models such as GPT, data sources, and tools into a single flow.
Instead of writing long prompt templates or hardcoding logic, you use components like chains, tools, and agents.
A simple example is binding together. For example, you would first ask the model to summarize the text, and then use the summary to generate the title. Langchain lets you define both steps and integrate them in code.
Here is a basic example in Python:
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o-mini")
prompt = PromptTemplate.from_template("Summarize the following text:\n{text}")
chain = LLMChain(prompt=prompt, llm=llm)
result = chain.run({"text": "LangChain helps developers build AI apps faster."})
print(result)
This simple stream takes text and runs it through an OpenAI model to get a summary. You can add more steps like a second chain to turn this summary into a topic or question.
Langchain provides modules for instant templates, models, retrievers, and tools so you can build workflows without managing raw API logic.
Here is the complete Lengchain documents.
Why Lingchen wasn’t enough
Lengchain makes building a straight-line workflow easy.
But most real-world applications are not linear. When building a chatbot, summarizer, or an autonomous agent, you often need loops, memory, and conditions.
For example, if the AI ​​makes a wrong assumption, you want it to try again. If it needs more data, it should call the search tool. Or if the user changes the context, the AI ​​should remember what was previously discussed.
Lengchain chains and agents could do some of this, but the flow was difficult to visualize and manage. You had to write nested chains or use callbacks to handle the decisions.
Developers wanted a better way to represent how AI systems actually think. Not in straight lines, but as graphs where outputs can lead to different paths.
This is why Lang was drawn to Graf.
What is a Lang Graph?
LangGraph is an extension of LangChain that introduces a graph-based approach to AI workflows.
Instead of chaining steps in a direction, Lang Graph lets you define nodes and edges like a flowchart. Each node can represent a task, action, or model call.
This structure allows for loops, branching and parallel paths. It is ideal for building agent-like systems where the model reasons, decides and acts.
Here is an example of a simple Lang Graph setup:
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
from langchain.agents import Tool
def multiply(a: int, b: int):
return a * b
tools = (Tool(name="multiply", func=multiply, description="Multiply two numbers"))
llm = ChatOpenAI(model="gpt-4o-mini")
agent_executor = create_react_agent(llm, tools)
graph = StateGraph()
graph.add_node("agent", agent_executor)
graph.set_entry_point("agent")
graph.add_edge("agent", END)
app = graph.compile()
response = app.invoke({"input": "Use the multiply tool to get 8 times 7"})
print(response)
This example shows a basic agent graph.
The AI ​​receives a request, reasons about it, decides to use the tool, and completes the task. You can imagine extending this to more complex graphs where the AI ​​can retry, call APIs, or fetch new information.
The Lang Graph gives you complete control over how the AI ​​moves between states. Each node can have conditions. For example, if a response is incomplete, you can send it back to another node to improve it.
This makes Lang Graph ideal for building systems that require multiple reasoning steps, such as document analysis bots, code reviewers, or research assistants.
Here is the complete Langgraf documents.
Langchen v. Langgraf
Langchain and Langgraf share the same foundation, but they approach workflow differently.
Langchain is linear. Each chain or agent moves from one step to the next in a sequence. Getting started is easy, especially for instant engineering, fetch-to-highlight generation, and structured pipelines.
Lang graph is dynamic. It represents the workflow as a graph which can be loop, branch and self correct. It is more powerful when agents require reasoning, planning, or memory.
A good analogy is this: Longchain is like writing a list of tasks in order. A Lang graph is similar to a flowchart drawing where decisions can lead to different steps or return to previous steps.
Most developers start with Langchain to learn the basics, then move to Langgraph when they want to build more interactive or autonomous AI systems.
When to use each
If you’re building simple tools like text summarizers, chatbots, or document retrievers, Langchain is sufficient. It’s easy to get started and integrates well with popular models like GPT, Claude and Gemini.
If you want to build multi-phase agents, or apps that think and adapt, go with Lang Graph. You can define how the AI ​​reacts to different results, and you have more control over retry logic, context switching, and feedback loops.
In practice, many developers combine the two. The Langchain provides the building blocks, while the Langgraph organizes how those blocks interact.
Adding memory and persistence
Both Langchain and Langgraph support memory, which allows your AI to remember the context between interactions. This is useful when you’re building chatbots, assistants, or agents that need information to act on.
For example, if a user introduces themselves once, the AI ​​should be able to recall that detail later in the conversation.
In Langchain, memory is managed by built-in modules ConversationBufferMemory or ConversationSummaryMemory. These let you store past inputs and outputs so that the model can refer to them in future responses.
Here’s a simple example using langchain:
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI
memory = ConversationBufferMemory()
llm = ChatOpenAI(model="gpt-4o-mini")
conversation = ConversationChain(llm=llm, memory=memory)
conversation.predict(input="Hello, I am Manish.")
response = conversation.predict(input="What did I just tell you?")
print(response)
In this case, the model remembers your previous message and replies accordingly. A memory object acts like a log of an ongoing conversation, as it evolves.
Langgraph takes this a step further by embedding memory in the state of the graph. Each node in the graph can access or update shared memory, allowing your AI to maintain context across multiple reasoning steps or branches. This approach is particularly useful when building agents that loop nodes, or rely on previous interactions.
Here’s how memory can be incorporated within a Lang Graph workflow:
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langgraph.prebuilt import create_react_agent
llm = ChatOpenAI(model="gpt-4o-mini")
memory = ConversationBufferMemory()
agent = create_react_agent(llm)
graph = StateGraph()
graph.add_node("chat", lambda state: agent.invoke({"input": state("input"), "memory": memory}))
graph.set_entry_point("chat")
graph.add_edge("chat", END)
app = graph.compile()
app.invoke({"input": "Hello, I am Manish."})
response = app.invoke({"input": "What did I just tell you?"})
print(response)
Here, the graph tracks memory between invoices. Although each call goes through the same node, shared ConversationBufferMemory Maintains what was said earlier. This design lets you build agents that remember the user’s context, maintain history, and when they move between nodes.
Whether you use a Langchain or a Langgraph, adding memory is what turns a simple workflow into a stateful system, one that can continue conversations, improve its reasoning, and respond naturally over time.
Monitoring and Debugging with LangSmith
Langsmith Another important tool in the langchain ecosystem is It helps you visualize, monitor and debug your AI applications.
When building workflows, you often want to see how the model behaves, how much it costs, and where things go wrong.
Langsmith records every call made by your chains and agents. You can view input and output data, timing, token usage and errors. It provides a dashboard that shows how your system performed in multiple runs.
You can easily integrate Langsmith by setting your environment variable:
export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="your_api_key_here"
After that, every LangChain or LangGraph process you run will be automatically logged into LangSmith. This helps developers find bugs, improve indicators and understand how the workflow behaves at each step.
Note that while Langchain and Langgraph are open source, LangSmith is a paid platform. LangSmith is a good tool to build AI workflows without any need.
The Langchain ecosystem
Lengchain is not just a library. It has grown into an ecosystem of tools that work together.
Lengchen Core: A central framework for chains, pointers and memory.
Lang Graf: A graph-based extension for building adaptive workflows.
Langsmith: Debugging and Monitoring Platform for AI Apps.
Langsro: A deployment layer that lets you convert your chains and graphs to an API with a single command.
Together, these tools form a complete stack for building, managing, and deploying model language applications. You can start with a simple chain, develop it into a graph-based system, test it with LangSmith, and deploy it using LangServ.
The result
Langchain and Langgraph make it easy to move from indicators to production-ready AI systems. Langchain helps you create a linear flow that connects models, data, and tools. Lang Graph lets you go further by building adaptive and intelligent workflows that reason and learn.
For beginners, starting with Langchain is the best way to understand how language models can interact with other components. As your projects grow, Lang Graph will give you the flexibility to handle complex logic and long-lived state.
Whether you’re building a chatbot, an agent, or a cognitive assistant, these tools will help you go from idea to implementation faster and more reliably.
Hope you enjoyed this article. Sign up for my free newsletter turingtalks.ai For more tutorials on AI. You can too Visit my website.