LangGraph Memory Agents: Python Code Tutorial

Large language models themselves have zero memory—they do not remember anything between interactions. The illusion of memory comes from external systems: browsers store message history locally, application backends persist conversation history to databases, and the inference API rebuilds the complete conversation history at each turn by sending the entire prompt including past messages.

Large Language Models are fundamentally stateless, meaning they cannot retain memory of previous interactions. Every bit of context must be explicitly passed with each request. The ChatGPT API solves this by using conversation IDs that link to previous messages, allowing the model to fetch and use historical context. This is why tools like ChatGPT and Gemini maintain conversation continuity—they actively pass conversation history to the model rather than relying on the model's inherent memory.

Large Language Models (LLMs) are fundamentally stateless systems that do not possess inherent memory; they respond to each prompt based solely on the information provided in that specific request. However, developers simulate memory by including the complete conversation history within every API request, allowing the model to understand context and maintain apparent continuity across interactions.

Large language models are fundamentally stateless, meaning they lack inherent memory of previous interactions. Despite this limitation, conversational memory is simulated through platform mechanisms. The platform packages relevant preceding conversation parts with new prompts, creating chat history that includes the system prompt, past user inputs, past AI responses, and the latest user query. This chat history is sent as a single input block to the LLM, enabling contextually relevant responses despite the model's stateless nature.

Context window is the maximum tokens an LLM can process (GPT-3.5: 4096, GPT-4: 128,000). LLMs are stateless, meaning they have no memory of previous interactions. Each request is treated independently. Applications must maintain conversation history externally and include it in subsequent prompts. This is why chat interfaces need to track and resend conversation history.

LangChain is a framework for developing language model applications through integration (connecting external data) and agency (enabling decision-making). Core schemas include Text (natural language programming), Chat Messages (system, human, AI types), and Documents (text with metadata). Models include Language models (text-to-text), Chat models (multi-turn conversations), and Embedding models (text-to-vector conversion). These foundational components enable developers to build sophisticated AI applications by abstracting complex technical details and providing reusable building blocks for language model interactions.

Chat models use three message schemas: System Message (defines AI behavior and role), Human Message (represents user input), and AI Message (represents model response). These schemas are essential for creating conversational AI applications. Chat models are created using 'from langchain.chat_models import ChatOpenAI' and 'ChatOpenAI(model='gpt-3.5-turbo', temperature=0.6)'. Conversational chatbots maintain context by storing all messages (system, human, and AI) in a list, allowing the AI to reference previous exchanges. The instructor demonstrates creating a comedian chatbot with system message 'You are a comedian AI assistant' and human message 'Please provide some comedy punch lines on AI'.

LangChain is an open-source framework (125K+ GitHub stars) that simplifies LLM application development by standardizing interfaces between providers like OpenAI, Anthropic, and Google. The ecosystem includes LangChain (core framework with Chains, Retrievers, Memory, Document Loaders), LangServe (production API deployment with FastAPI), and LangSmith (observability for monitoring and evaluation). LangGraph extends LangChain with stateful orchestration using graph structures supporting loops, conditional branching, and persistent state. The v1.0 migration introduced create_agent replacing create_react_agent, flexible middleware for execution control, and separate model/tool parameters enabling dynamic integration. Basic agent creation requires importing create_agent, defining tools, and passing model, tools, and system prompt.

LangChain is built around three core components: Chains are sequences of steps that process information (e.g., take input, reformat, send to LLM, post-process, return answer), making AI logic easier to debug, test, and extend. Tools allow LLMs to interact with the outside world (search engines, databases, APIs, calculators), providing a standard way to define what tools exist and when to use them. Agents allow models to decide what action to take, choose which tool to use, observe results, and decide next steps, adding decision-making ability but introducing risk that requires reliability and observability measures.

Chains are the core LangChain concept where language models and tools are placed sequentially to achieve results. The input of one model becomes the output of the previous, enabling complex multi-step tasks. An AI agent is a language model with tools that can make decisions and reason about which tools to use based on queries and environment. Unlike basic chatbots, agents are autonomous—they perform tasks without constant human interaction, can autocorrect errors, and handle complex workflows like checking dates, searching APIs, and generating outputs independently.

LangGraph has four essential concepts: State (shared data storage for the entire workflow), Node (individual functions performing specific tasks), Edge (connections defining flow between nodes), and Persistence/Checkpoint (ability to save and restore workflow state). State serves as the central data repository that all nodes can read from and write to, enabling data sharing across different workflow stages. Nodes are Python functions encapsulating specific workflow logic. Edges define connection paths between nodes, including conditional logic for dynamic branching. Persistence and Checkpoint mechanisms allow workflows to save their state and history, enabling workflows to be resumed from specific points, history to be reviewed, and processes to be interrupted and later continued. This is essential for long-running workflows requiring pause and resume capabilities.

Lang Graph implements stateful graphs parameterized by a state object passed between nodes. Each node receives the state, performs operations, and returns updated state. Operations can either set specific attributes on the state or add to existing attributes, denoted by annotations when constructing the graph. For example, tracking conversation history involves adding messages to a list attribute. The graph defines entry points, adds nodes (agents or actions), sets conditional edges based on output logic, adds normal edges connecting actions back to agents, and compiles into a runnable workflow. This enables complex state management within graph structures.

In graph-based systems, state serves as a shared document that all nodes access and modify. The state contains multiple fields: 'input' stores the original message, 'assigned node' tracks which node handles the task, and 'prev node to write' logs the workflow progression. Nodes pass this state to each other, and when discrepancies occur (e.g., incorrect task assignment), nodes can detect and self-correct by overwriting the state fields. LangGraph requires states to be defined using TypedDict format, which enforces specific data types for each key (input as string, assigned node as integer, prev node to write as string), ensuring type safety during graph execution.

LangGraph is a framework developed by LangChain that enables the construction of stateful graph-based workflows for AI-driven applications. The framework consists of three core components: State (shared context across nodes using Python types like TypedDict or Pydantic), Nodes (functions that perform specific tasks such as LLM interactions, API calls, or data transformations), and Edges (connections that define execution flow between nodes). LangGraph offers two execution models: Graph (simple execution flow without built-in state retention, suitable for stateless workflows) and StateGraph (stateful execution where nodes can modify and retain shared state throughout the workflow, essential for complex AI applications requiring context retention like multi-turn conversations and iterative processing).

LangGraph follows the Google Pregel execution model for large-scale graph processing. The execution process involves: (1) Graph definition - defining state schema, nodes (Python functions), and edges (connections); (2) Compilation - checking graph structure and preparing for execution; (3) Invocation - passing initial state to the first node; (4) Super steps - rounds of execution where nodes activate based on message passing through edges; (5) Halting conditions - execution stops when all nodes are activated and no messages are in transit. Each node is a simple Python function performing a specific task. This model enables efficient execution of complex graph-based workflows with proper message passing and state management.