of highly effective AI fashions, akin to GPT-5 and Gemini 2.5 Professional, we additionally see a rise in agentic frameworks to make the most of these fashions. These frameworks make working with AI fashions easier by abstracting away lots of challenges, akin to tool-calling, agentic state dealing with, and human-in-the-loop setups.
Thus, on this article, I’ll dive deeper into LangGraph, one of many obtainable agentic AI frameworks. I’ll put it to use to develop a easy agentic software, with a number of steps highlighting the advantages of agentic AI packages. I’ll additionally cowl the professionals and cons of utilizing LangGraph and different related agentic frameworks.
I’m not sponsored in any means by LangGraph to create this text. I merely selected the framework because it is likely one of the most prevalent ones on the market. There are a lot of different choices on the market, akin to:
- LangChain
- LlamaIndex
- CrewAI
Why do you want an agentic framework?
There are quite a few packages on the market which might be speculated to make programming functions simpler. In lots of instances, these packages have the precise reverse impact, as a result of they obscure the code, don’t work properly in manufacturing, and generally make it tougher to debug.
Nevertheless, you must discover the packages that simplify your software by abstracting away boilerplate code. This precept is usually highlighted within the startup world with a quote just like the one under:
Give attention to fixing the precise drawback you’re attempting to unravel. All different (beforehand solved issues) needs to be outsourced to different functions
An agentic framework is required as a result of it abstracts away lots of issues you don’t want to take care of:
- Sustaining state. Not simply message historical past, however all different info you collect, for instance, when performing RAG
- Software utilization. You don’t wish to arrange your personal logic for executing instruments. Quite, you need to merely outline them and let the agentic framework deal with how you can invoke the instruments. (That is particularly related for parallel and async software calling)
Thus, utilizing an agentic framework abstracts away lots of issues, so you’ll be able to give attention to the core a part of your product.
Fundamentals of LangGraph
To get began implementing LangGraph, I start by studying the docs, overlaying:
- Primary chatbot implementation
- Software utilization
- Sustaining and updating the state
LangGraph is, as its title suggests, based mostly on constructing graphs and executing this graph per request. In a graph, you’ll be able to outline:
- The state (the present info saved in reminiscence)
- Nodes. Sometimes, an LLM or a software name, for instance, classifying person intent, or answering the person’s query
- Edges. Conditional logic determines which node to go to subsequent.
All of which stems from fundamental graph concept.
Implementing a workflow
I imagine among the finest methods of studying is to easily strive issues out for your self. Thus, I’ll implement a easy workflow in LangGraph. You’ll be able to study constructing these workflows within the workflow docs, which is predicated on Anthropic’s Constructing efficient brokers weblog (one in all my favourite weblog posts about brokers, which I’ve lined in a number of of my earlier articles. I extremely suggest studying it.
I’ll make a easy workflow to outline an software the place a person can:
- Create paperwork with textual content
- Delete paperwork
- Search in paperwork
To do that, I’ll create the next workflow:
- Detect person intent. Do they wish to create a doc, delete a doc, or search in a doc?
- Given the end result of step 1, I’ll have completely different flows to deal with every of them.
You could possibly additionally do that by merely defining all of the instruments and giving the agent entry to create/delete/search a doc. Nevertheless, if you wish to do extra actions relying on intent, doing an intent classification routing step first is the way in which to go.
Loading imports and LLM
First, I’ll load the required imports and the LLM I’m utilizing. I’ll be utilizing AWS Bedrock, although you need to use different suppliers, as you’ll be able to see from step 3 on this tutorial.
"""
Make a doc handler workflow the place a person can
create a brand new doc to the database (at present only a dictionary)
delete a doc from the database
ask a query a few doc
"""
from typing_extensions import TypedDict, Literal
from langgraph.checkpoint.reminiscence import InMemorySaver
from langgraph.graph import StateGraph, START, END
from langgraph.varieties import Command, interrupt
from langchain_aws import ChatBedrockConverse
from langchain_core.messages import HumanMessage, SystemMessage
from pydantic import BaseModel, Discipline
from IPython.show import show, Picture
from dotenv import load_dotenv
import os
load_dotenv()
aws_access_key_id = os.getenv("AWS_ACCESS_KEY_ID") or ""
aws_secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY") or ""
os.environ["AWS_ACCESS_KEY_ID"] = aws_access_key_id
os.environ["AWS_SECRET_ACCESS_KEY"] = aws_secret_access_key
llm = ChatBedrockConverse(
model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0", # that is the mannequin id (added us. earlier than id in platform)
region_name="us-east-1",
aws_access_key_id=aws_access_key_id,
aws_secret_access_key=aws_secret_access_key,
)
document_database: dict[str, str] = {} # a dictionary with key: filename, worth: textual content in doc
I additionally outlined the database as a dictionary of recordsdata. In manufacturing, you’ll naturally use a correct database; nonetheless, I simplify it for this tutorial
Defining the graph
Subsequent, it’s time to outline the graph. I first create the Router object, which can classify the person’s immediate into one in all three intents:
- add_document
- delete_document
- ask_document
# Outline state
class State(TypedDict):
enter: str
determination: str | None
output: str | None
# Schema for structured output to make use of as routing logic
class Route(BaseModel):
step: Literal["add_document", "delete_document", "ask_document"] = Discipline(
description="The subsequent step within the routing course of"
)
# Increase the LLM with schema for structured output
router = llm.with_structured_output(Route)
def llm_call_router(state: State):
"""Route the person enter to the suitable node"""
# Run the augmented LLM with structured output to function routing logic
determination = router.invoke(
[
SystemMessage(
content="""Route the user input to one of the following 3 intents:
- 'add_document'
- 'delete_document'
- 'ask_document'
You only need to return the intent, not any other text.
"""
),
HumanMessage(content=state["input"]),
]
)
return {"determination": determination.step}
# Conditional edge operate to path to the suitable node
def route_decision(state: State):
# Return the node title you wish to go to subsequent
if state["decision"] == "add_document":
return "add_document_to_database_tool"
elif state["decision"] == "delete_document":
return "delete_document_from_database_tool"
elif state["decision"] == "ask_document":
return "ask_document_tool"
I outline the state the place we retailer the person enter, the router’s determination (one of many three intents), after which guarantee structured output from the LLM. The structured output ensures the mannequin responds with one of many three intents.
Persevering with, I’ll outline the instruments we’re utilizing on this article, one for every of the intents.
# Nodes
def add_document_to_database_tool(state: State):
"""Add a doc to the database. Given person question, extract the filename and content material for the doc. If not supplied, won't add the doc to the database."""
user_query = state["input"]
# extract filename and content material from person question
filename_prompt = f"Given the next person question, extract the filename for the doc: {user_query}. Solely return the filename, not another textual content."
output = llm.invoke(filename_prompt)
filename = output.content material
content_prompt = f"Given the next person question, extract the content material for the doc: {user_query}. Solely return the content material, not another textual content."
output = llm.invoke(content_prompt)
content material = output.content material
# add doc to database
document_database[filename] = content material
return {"output": f"Doc {filename} added to database"}
def delete_document_from_database_tool(state: State):
"""Delete a doc from the database. Given person question, extract the filename of the doc to delete. If not supplied, won't delete the doc from the database."""
user_query = state["input"]
# extract filename from person question
filename_prompt = f"Given the next person question, extract the filename of the doc to delete: {user_query}. Solely return the filename, not another textual content."
output = llm.invoke(filename_prompt)
filename = output.content material
# delete doc from database if it exsits, if not retunr information about failure
if filename not in document_database:
return {"output": f"Doc {filename} not present in database"}
document_database.pop(filename)
return {"output": f"Doc {filename} deleted from database"}
def ask_document_tool(state: State):
"""Ask a query a few doc. Given person question, extract the filename and query for the doc. If not supplied, won't ask the query concerning the doc."""
user_query = state["input"]
# extract filename and query from person question
filename_prompt = f"Given the next person question, extract the filename of the doc to ask a query about: {user_query}. Solely return the filename, not another textual content."
output = llm.invoke(filename_prompt)
filename = output.content material
question_prompt = f"Given the next person question, extract the query to ask concerning the doc: {user_query}. Solely return the query, not another textual content."
output = llm.invoke(question_prompt)
query = output.content material
# ask query about doc
if filename not in document_database:
return {"output": f"Doc {filename} not present in database"}
outcome = llm.invoke(f"Doc: {document_database[filename]}nnQuestion: {query}")
return {"output": f"Doc question outcome: {outcome.content material}"}And eventually, we construct the graph with nodes and edges:
# Construct workflow
router_builder = StateGraph(State)
# Add nodes
router_builder.add_node("add_document_to_database_tool", add_document_to_database_tool)
router_builder.add_node("delete_document_from_database_tool", delete_document_from_database_tool)
router_builder.add_node("ask_document_tool", ask_document_tool)
router_builder.add_node("llm_call_router", llm_call_router)
# Add edges to attach nodes
router_builder.add_edge(START, "llm_call_router")
router_builder.add_conditional_edges(
"llm_call_router",
route_decision,
{ # Title returned by route_decision : Title of subsequent node to go to
"add_document_to_database_tool": "add_document_to_database_tool",
"delete_document_from_database_tool": "delete_document_from_database_tool",
"ask_document_tool": "ask_document_tool",
},
)
router_builder.add_edge("add_document_to_database_tool", END)
router_builder.add_edge("delete_document_from_database_tool", END)
router_builder.add_edge("ask_document_tool", END)
# Compile workflow
reminiscence = InMemorySaver()
router_workflow = router_builder.compile(checkpointer=reminiscence)
config = {"configurable": {"thread_id": "1"}}
# Present the workflow
show(Picture(router_workflow.get_graph().draw_mermaid_png()))
The final show operate ought to present the graph as you see under:
Now you’ll be able to check out the workflow by asking a query per intent.
Add a doc:
user_input = "Add the doc 'check.txt' with content material 'This can be a check doc' to the database"
state = router_workflow.invoke({"enter": user_input}, config)
print(state["output"]
# -> Doc check.txt added to databaseSearch a doc:
user_input = "Give me a abstract of the doc 'check.txt'"
state = router_workflow.invoke({"enter": user_input}, config)
print(state["output"])
# -> A quick, generic check doc with a easy descriptive sentence.Delete a doc:
user_input = "Delete the doc 'check.txt' from the database"
state = router_workflow.invoke({"enter": user_input}, config)
print(state["output"])
# -> Doc check.txt deleted from databaseNice! You’ll be able to see the workflow is working with the completely different routing choices. Be happy so as to add extra intents or extra nodes per intent to create a extra advanced workflow.
Stronger agentic use instances
The distinction between agentic workflows and totally agentic functions is typically complicated. Nevertheless, to separate the 2 phrases, I’ll use the quote under from Anthropic’s Constructing efficient brokers:
Workflows are techniques the place LLMs and instruments are orchestrated via predefined code paths. Brokers, alternatively, are techniques the place LLMs dynamically direct their very own processes and power utilization, sustaining management over how they accomplish duties.
Most challenges you remedy with LLMs will use the workflow sample, as a result of most issues (from my expertise) are pre-defined, and may have a pre-determined set of guardrails to observe. Within the instance above, when including/deleting/looking paperwork, you need to completely arrange a pre-determined workflow by defining the intent classifier and what to do given every intent.
Nevertheless, generally, you additionally need extra autonomous agentic use instances. Think about, for instance, Cursor, the place they need a coding agent that may search via your code, examine the most recent documentation on-line, and modify your code. In these situations, it’s troublesome to create pre-determined workflows as a result of there are such a lot of completely different situations that may happen.
If you wish to create extra autonomous agentic techniques, you’ll be able to learn extra about that right here.
LangGraph execs and cons
Professionals
My three primary positives about LangGraph are:
- Straightforward to arrange
- Open-source
- Simplifies your code
It was easy to arrange LangGraph and shortly get it working. Particularly when following their documentation, or feeding their documentation to Cursor and prompting it to implement particular workflows.
Moreover, the code for LangGraph is open-source, which means you’ll be able to hold working the code, it doesn’t matter what occurs to the corporate behind it or adjustments they resolve to make. I feel that is essential if you wish to deploy it to manufacturing. Lastly, LangGraph additionally simplifies lots of the code and abstracts away lots of logic you’ll’ve needed to write in Python your self.
Cons
Nevertheless, there are additionally some downsides to LangGraph that I’ve seen throughout implementation.
- Nonetheless a shocking quantity of boilerplate code
- You’ll encounter LangGraph-specific errors
When implementing my very own customized workflow, I felt I nonetheless had so as to add lots of boilerplate code. Although the quantity of code was positively lower than if I’d applied all the pieces from scratch, I discovered myself shocked by the quantity of code I had so as to add to create a comparatively easy workflow. Nevertheless, I feel a part of that is that LangGraph makes an attempt to place itself as a lower-code software than, for instance, lots of performance you discover in LangChain (which I feel is nice as a result of LangChain, in my view, abstracts away an excessive amount of, making it tougher to debug your code).
Moreover, as with many externally put in packages, you’ll encounter LangGraph-specific points when implementing the package deal. For instance, once I needed to preview the graph of the workflow I created, I bought a difficulty regarding the draw_mermaid_png operate. Encountering such errors is inevitable when utilizing exterior packages, and it’ll all the time be a trade-off between the useful code abstractions a package deal provides you, versus the completely different sorts of bugs it’s possible you’ll face utilizing such packages.
Abstract
All in all, I discover LangGraph a useful package deal when coping with agentic techniques. Organising my desired workflow by first doing intent classification and continuing with completely different flows relying on intent was comparatively easy. Moreover, I feel LangGraph discovered center floor between not abstracting away all logic (obscuring the code, making it tougher to debug) and truly abstracting away challenges I don’t wish to take care of when creating my agentic system. There are each positives and negatives to implementing such agentic frameworks, and I feel one of the best ways to make this trade-off is by implementing easy workflows your self.
👉 Discover me on socials:
🧑💻 Get in contact
✍️ Medium
If you wish to study extra about agentic workflows, you’ll be able to learn my article on Constructing Efficient AI Brokers To Course of Hundreds of thousands of Paperwork. You may as well study extra about LLMs in my article on LLM Validation.
