Think of it as a way to build AI agents that don’t just chat, but actually do things<\/em>.<\/p>\n We\u2019ll use uv<\/a> as our package manager instead of pip for this project. uv is a super-fast tool, written in Rust, that helps you manage Python packages.<\/p>\n Sign up at Groq Console<\/a> for a free API key, then create This LangGraph-powered AI agent is designed to assist HR teams in mobile development hiring. It showcases how LangGraph can be used to build versatile agents for various tasks. The demo covers key LangGraph concepts, including nodes, edges, state management, memory, and tool integration, offering a comprehensive understanding of the framework.<\/p>\n a) State<\/span>: Manages conversation flow and candidate data a) Short-term Memory<\/span>: Maintains the current conversation history and session state. langgraph_agent<\/p><\/div>\n a) Start<\/span>: The candidate selection process begins. 1. Runnables<\/strong><\/p>\n a) Building blocks that can be chained together 2. State Management<\/strong><\/p>\n a) Central data structure flowing through workflow 3. Nodes<\/strong><\/p>\n a) Processing units in the workflow 4. Edges<\/strong><\/p>\n a) Define flow between nodes 5. Memory Systems<\/strong><\/p>\n a) Short-term: Conversation history within session 6. Tools<\/strong><\/p>\n a) Functions the AI can call autonomously 7. Parallelism<\/strong><\/p>\n a) Multiple operations run simultaneously 1. Memory Summarisation<\/strong><\/p>\n a) LLM creates concise summaries of long conversations 2. Tool State Updates<\/strong><\/p>\n a) Tools can update workflow state using `Command` objects 3. Conditional Workflow<\/strong><\/p>\n a) Dynamic routing based on conversation state 4. Multi-LLM Support<\/strong><\/p>\n a) Easy switching between LLM providers (Groq, OpenAI) 1. Start Simple<\/strong><\/p>\n a) Begin with basic prompt + LLM chain 2. State Design<\/strong><\/p>\n a) Keep state model focused and minimal 3. Tool Development<\/strong><\/p>\n a) Write clear docstrings for each tool 4. Memory Strategy<\/strong><\/p>\n a) Design memory structure early 5. Debugging<\/strong><\/p>\n a) Add print statements to understand flow Using LangGraph to Create an AI Agent- Beginner Guide Are you ready to create an AI agent effectively? In this post, we’ll use LangGraph, a robust framework for developing stateful, multi-step AI applications, to develop a basic candidate shortlisting agent that will demonstrate multiple LangGraph features. What is LangGraph? LangGraph, built on Langchain, is a […]<\/p>\n","protected":false},"author":1786,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":99},"categories":[5879],"tags":[7765,5733,5918,7766,6263,7764],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/74009"}],"collection":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/users\/1786"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/comments?post=74009"}],"version-history":[{"count":9,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/74009\/revisions"}],"predecessor-version":[{"id":76516,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/74009\/revisions\/76516"}],"wp:attachment":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/media?parent=74009"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/categories?post=74009"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/tags?post=74009"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}Quick Setup<\/h2>\n
1. Install uv<\/h3>\n
# On macOS\/Linux\r\nbrew install uv<\/code><\/pre>\n2. Create Project<\/h3>\n
mkdir candidate_agent_lg\r\ncd candidate_agent_lg\r\nuv init\r\nuv add langgraph langchain-core langchain-groq python-dotenv pydantic<\/code><\/pre>\n3. Get API Key<\/h3>\n
.env<\/code>:<\/p>\nGROQ_API_KEY=your_api_key_here<\/code><\/pre>\nThe Agent Architecture<\/h1>\n
Key Components Explained:<\/strong><\/h2>\n
\nb) Tools<\/span>: Functions the agent can call to perform specific tasks
\nc) Nodes<\/span>: Processing units that handle different aspects of the workflow
\nd) Edges<\/span>: Define the flow between nodes
\ne) Memory<\/span>: Stores conversation history and candidate insights<\/p>\nMemory System:<\/strong><\/h2>\n
\nb) Long-term Memory<\/span>: Stores HR preferences, agent insights, and records of past candidate evaluations.<\/p>\nWorkflow Steps<\/strong><\/h2>\n
![\"agent_flowchart\"](\"https:\/\/www.tothenew.com\/blog\/wp-ttn-blog\/uploads\/2025\/09\/agent_flowchart-1024x961.png\")
\nb) LLM Call Node<\/span>: The agent processes user requests, retrieves relevant memories, and determines the next action.
\nc) Decision Point<\/span>: The agent decides whether tool calls are needed.
\n– If yes, it uses the available tools (evaluate, assess, schedule, verify).
\n– If no, it updates memory with new insights for future use.
\nd) Tool Node<\/span>: Executes the selected tools and updates candidate evaluation data.
\ne) Memory Updates:<\/span> In parallel, the agent updates:
\n– Agent Memory: Stores recommendations and evaluation patterns.
\n– User Memory: Stores HR preferences and hiring criteria.
\nf) End<\/span>: The workflow completes, leaving the system with updated<\/p>\n
\nDetailed Summary:<\/strong><\/h1>\n
\n
from langchain_groq import ChatGroq\r\nfrom langchain_core.prompts import ChatPromptTemplate\r\nfrom langchain_core.prompts.chat import MessagesPlaceholder\r\n\r\nllm = ChatGroq(model=\"gemma2-9b-it\", temperature=0)\r\nprompt = ChatPromptTemplate.from_messages([\r\n(\"system\", \"You are an HR assistant for mobile dev hiring. Respond in {language}.\"),\r\nMessagesPlaceholder(\"messages\"),\r\n])\r\nbot = prompt | llm<\/pre>\n\n
from pydantic import BaseModel\r\nfrom typing import Annotated\r\nfrom langgraph.graph import StateGraph, START, END\r\nfrom langgraph.graph.message import add_messages\r\n\r\nclass State(BaseModel):\r\nmessages: Annotated[list, add_messages]\r\nlanguage: str | None = \"English\"\r\n\r\ndef llm_call(state: State):\r\nmsg = (prompt | llm).invoke({\"messages\": state.messages, \"language\": state.language})\r\nreturn {\"messages\": [msg]}\r\n\r\ng = StateGraph(State)\r\ng.add_node(\"llm_call\", llm_call)\r\ng.add_edge(START, \"llm_call\")\r\ng.add_edge(\"llm_call\", END)\r\ngraph = g.compile()<\/pre>\n\n
from langgraph.checkpoint.memory import InMemorySaver\r\ngraph = g.compile(checkpointer=InMemorySaver())\r\nconfig = {\"configurable\": {\"thread_id\": \"1\"}}<\/pre>\n\n
from langgraph.store.memory import InMemoryStore\r\nstore = InMemoryStore()\r\n\r\ndef concat(items): return \"\\n\".join(i.dict()[\"value\"][\"memory\"] for i in items if \"memory\" in i.dict().get(\"value\", {}))\r\n\r\ndef llm_call_with_mem(state: State, *, store=store):\r\nhr = concat(store.search((\"user_1\", \"HR Preferences\")))\r\nai = concat(store.search((\"user_1\", \"Agent Insights\")))\r\nmsg = (prompt | llm).invoke({\r\n\"messages\": state.messages, \"language\": state.language,\r\n\"hr_summary\": hr, \"agent_summary\": ai\r\n})\r\nreturn {\"messages\": [msg]}<\/pre>\n\n
def go_to(state: State):\r\nlast = state.messages[-1]\r\nreturn \"tools\" if getattr(last, \"tool_calls\", []) else [\"update_user_memory\", \"update_agent_memory\"]\r\n\r\ng = StateGraph(State)\r\ng.add_node(\"llm_call\", llm_call_with_mem)\r\ng.add_node(\"tools\", lambda s: s) # placeholder\r\ng.add_node(\"update_user_memory\", lambda s, *, store=None: {})\r\ng.add_node(\"update_agent_memory\", lambda s, *, store=None: {})\r\ng.add_edge(START, \"llm_call\")\r\ng.add_conditional_edges(\"llm_call\", go_to, [\"tools\", \"update_user_memory\", \"update_agent_memory\"])\r\ng.add_edge(\"tools\", \"llm_call\")\r\ng.add_edge(\"update_user_memory\", END)\r\ng.add_edge(\"update_agent_memory\", END)\r\ngraph = g.compile(checkpointer=InMemorySaver(), store=store)<\/pre>\n<\/li>\nfrom langchain_core.tools import tool, InjectedToolCallId\r\nfrom langchain_core.messages import ToolMessage\r\nfrom langgraph.types import Command\r\nfrom langgraph.prebuilt import ToolNode\r\nfrom typing import Annotated\r\n\r\n@tool\r\ndef evaluate_candidate(name: str, role: str, tool_call_id: Annotated[str, InjectedToolCallId]):\r\nresult = f\"{name} for {role}: 75\/100\"\r\nreturn Command(update={\"messages\": [ToolMessage(result, tool_call_id=tool_call_id)]})\r\n\r\n@tool\r\ndef schedule_interview(name: str, date: str, tool_call_id: Annotated[str, InjectedToolCallId]):\r\ninfo = f\"Interview scheduled for {name} on {date}\"\r\nreturn Command(update={\"messages\": [ToolMessage(info, tool_call_id=tool_call_id)]})\r\n\r\ntools = [evaluate_candidate, schedule_interview]\r\ntool_node = ToolNode(tools)\r\nllm_with_tools = llm.bind_tools(tools)\r\n\r\ndef llm_call(state: State):\r\nmsg = (prompt | llm_with_tools).invoke({\"messages\": state.messages, \"language\": state.language})\r\nreturn {\"messages\": [msg]}<\/pre>\n<\/li>\n<\/ul>\n
\nKey Concepts Summary<\/strong><\/h1>\n
\nb) Examples: Prompts, LLMs, Tools
\nc) Chain with `|` operator: `prompt | llm`<\/p>\n
\nb) Defined using Pydantic models
\nc) Updated by nodes and tools<\/p>\n
\nb) Python functions that take state and return updates
\nc) Handle specific aspects (conversation, tools, memory)<\/p>\n
\nb) Can be conditional (based on state)
\nc) Enable complex decision-making workflows<\/p>\n
\nb) Long-term: Persistent insights across sessions
\nc) Namespaced: Organised by user and memory type<\/p>\n
\nb) Decorated with `@tool`
\nc) Enable specialised capabilities<\/p>\n
\nb) Conditional edges can return multiple destinations
\nc) Improves performance and efficiency<\/p>\n
\nAdvanced Features Demonstrated<\/strong><\/h1>\n
\nb) Maintains context while reducing token usage
\nc) Separate prompts for user and agent memories<\/p>\n
\nb) Enables complex state modifications from within tools
\nc) Maintains traceability with `tool_call_id`<\/p>\n
\nb) Agent decides whether to use tools or update memory
\nc) Flexible workflow adaptation<\/p>\n
\nb) Consistent interface across different models
\nc) Fallback options for reliability<\/p>\n
\nBest Practices for Beginners<\/strong><\/h1>\n
\nb) Add complexity gradually (nodes, then tools, then memory)
\nc) Test each component before adding the next<\/p>\n
\nb) Use Optional fields for flexibility
\nc) Document what each field represents<\/p>\n
\nb) Start with simple tools, add complexity later
\nc) Test tools independently before integration<\/p>\n
\nb) Use namespaces to organise different memory types
\nc) Implement memory summarisation to control size<\/p>\n
\nb) Enable LangChain tracing for detailed debugging
\nc) Test with simple inputs first<\/p>\n
\nUseful Resources<\/h1>\n
\n