State schema definition in LangChain

Introduction

State schema definition helps you organize and control the data your app uses. It makes sure your app knows what kind of information to expect and how to handle it.

When you want to keep track of user inputs in a chat or form.

When you need to remember previous steps in a conversation.

When you want to validate the data your app processes.

When you want to structure complex data for easier management.

When you want to ensure consistent data formats across your app.

Syntax

LangChain

from langchain.memory import BaseMemory

class MyStateSchema(BaseMemory):
    def __init__(self):
        self.user_name: str = ""
        self.user_age: int = 0

    def load_memory_variables(self):
        return {"user_name": self.user_name, "user_age": self.user_age}

    def save_context(self, inputs, outputs):
        self.user_name = inputs.get("name", "")
        self.user_age = int(inputs.get("age", 0))

State schema is usually a class that holds variables representing your app's data.

It includes methods to load and save data, so your app can remember information between steps.

Examples

This example counts how many times the state is updated.

LangChain

class SimpleState(BaseMemory):
    def __init__(self):
        self.count = 0

    def load_memory_variables(self):
        return {"count": self.count}

    def save_context(self, inputs, outputs):
        self.count += 1

This example stores and retrieves a user's email address.

LangChain

class UserInfoState(BaseMemory):
    def __init__(self):
        self.user_email = ""

    def load_memory_variables(self):
        return {"email": self.user_email}

    def save_context(self, inputs, outputs):
        self.user_email = inputs.get("email", "")

Sample Program

This program defines a simple chat state that remembers the last message sent by the user. It saves the message and then loads it to show what is stored.

LangChain

from langchain.memory import BaseMemory

class ChatState(BaseMemory):
    def __init__(self):
        self.last_message = ""

    def load_memory_variables(self):
        return {"last_message": self.last_message}

    def save_context(self, inputs, outputs):
        self.last_message = inputs.get("message", "")

# Simulate usage
chat_state = ChatState()

# User sends a message
chat_state.save_context({"message": "Hello!"}, {})

# Load stored state
state_data = chat_state.load_memory_variables()
print(state_data)

Important Notes

Always define clear methods to load and save your state data.

Keep your state schema simple and focused on the data you need to remember.

Test your state schema by simulating inputs and checking stored outputs.

Summary

State schema defines how your app stores and retrieves data.

It uses classes with variables and methods to manage state.

Good state management helps your app remember important information smoothly.

Practice

1. What is the main purpose of defining a state schema in a Langchain application?

easy

A. To specify how the app stores and manages its data

B. To create user interface components

C. To write SQL queries for databases

D. To handle network requests and responses

Solution

1. Step 1: Understand the role of state schema

   A state schema defines the structure and rules for storing data in an app.

2. Step 2: Differentiate from other app parts

   UI components, SQL queries, and network handling are unrelated to state schema definition.

3. Final Answer:

   To specify how the app stores and manages its data -> Option A

4. Quick Check:

   State schema = data structure [OK]

Hint: State schema = data storage rules in app [OK]

Common Mistakes:

• Confusing state schema with UI design
• Thinking state schema handles network calls
• Mixing state schema with database query writing

2. Which of the following is the correct way to define a simple state schema class in Langchain?

easy

A. StateSchema = {value: None}

B. def StateSchema():
value = None

C. class StateSchema:
def __init__(self):
self.value = None

D. class StateSchema:
value = None
def __init__(self):
pass

Solution

1. Step 1: Identify correct class syntax

   class StateSchema: def __init__(self): self.value = None correctly defines a class with an __init__ method setting an instance variable.

2. Step 2: Check other options for errors

   def StateSchema(): value = None is a function, not a class; C is a dict, not a class; D defines a class but does not initialize instance variables properly.

3. Final Answer:

   class StateSchema:\n def __init__(self):\n self.value = None -> Option C

4. Quick Check:

   Class with __init__ and self.value = None = A [OK]

Hint: Class with __init__ and self.variable is correct [OK]

Common Mistakes:

• Defining a function instead of a class
• Using dictionary syntax instead of class
• Not initializing instance variables inside __init__

3. Given this state schema class in Langchain:

class UserState:
    def __init__(self):
        self.name = ''
        self.age = 0

state = UserState()
state.name = 'Alice'
state.age = 30
print(state.name, state.age)

What will be printed?

medium

A. Alice 30

B. '' 0

C. name age

D. Error: name and age not defined

Solution

1. Step 1: Understand class initialization

   The UserState class initializes name as empty string and age as 0.

2. Step 2: Check assigned values before print

   state.name is set to 'Alice' and state.age to 30 before printing.

3. Final Answer:

   Alice 30 -> Option A

4. Quick Check:

   Assigned values printed = Alice 30 [OK]

Hint: Print shows assigned values, not defaults [OK]

Common Mistakes:

• Assuming default values print instead of assigned
• Confusing variable names with strings
• Expecting error due to missing attributes

4. Identify the error in this Langchain state schema definition:

class AppState:
    def __init__(self):
        self.count = 0

state = AppState()
print(state.counter)

medium

A. TypeError because count is an integer

B. SyntaxError due to missing colon

C. No error, prints 0

D. AttributeError because 'counter' is not defined

Solution

1. Step 1: Check attribute names

   The class defines 'count' but the print statement uses 'counter'.

2. Step 2: Understand Python attribute errors

   Accessing an undefined attribute causes AttributeError at runtime.

3. Final Answer:

   AttributeError because 'counter' is not defined -> Option D

4. Quick Check:

   Wrong attribute name = AttributeError [OK]

Hint: Check attribute names carefully for typos [OK]

Common Mistakes:

• Assuming print shows 0 despite wrong attribute
• Thinking it's a syntax error
• Confusing attribute error with type error

5. You want to define a state schema that stores a user's name (string), age (integer), and a list of tasks (strings). Which class definition correctly models this in Langchain?

hard

A. class UserState:
name = ''
age = 0
tasks = []

B. class UserState:
def __init__(self):
self.name = ''
self.age = 0
self.tasks = []

C. class UserState:
def __init__(self):
self.name = None
self.age = None
self.tasks = None

D. class UserState:
def __init__(self):
self.name = ''
self.age = ''
self.tasks = ''

Solution

1. Step 1: Check correct initialization of instance variables

   class UserState: def __init__(self): self.name = '' self.age = 0 self.tasks = [] initializes name as empty string, age as 0, and tasks as empty list, matching the required types.

2. Step 2: Evaluate other options for type correctness

   class UserState: name = '' age = 0 tasks = [] uses class variables, not instance variables; C sets tasks to None instead of list; D sets age and tasks as empty strings, wrong types.

3. Final Answer:

   class UserState:\n def __init__(self):\n self.name = ''\n self.age = 0\n self.tasks = [] -> Option B

4. Quick Check:

   Instance vars with correct types = B [OK]

Hint: Use __init__ with correct types for each variable [OK]

Common Mistakes:

• Using class variables instead of instance variables
• Setting wrong default types (e.g., string instead of int)
• Initializing list variables as None or empty string