State schema definition in LangChain - Step-by-Step Execution

Concept Flow - State schema definition

Define schema fields

↓

Set field types and defaults

↓

Create schema object

↓

Use schema to validate or store state

↓

Access or update state via schema

This flow shows how to define a state schema by specifying fields and types, creating the schema object, and then using it to manage state.

Execution Sample

LangChain

from langchain.schema import State

state = State(
  user_name=str,
  count=int,
  active=bool
)

state.user_name = "Alice"

Defines a state schema with fields user_name, count, and active, then sets user_name to 'Alice'.

Execution Table

Step	Action	Field/Variable	Value/Type	Result/State
1	Define State schema	user_name	str	Schema created with user_name:str
2	Define State schema	count	int	Schema created with count:int
3	Define State schema	active	bool	Schema created with active:bool
4	Create State instance	state	State object	state with fields user_name, count, active
5	Assign value	state.user_name	"Alice"	state.user_name set to 'Alice'
6	Access value	state.user_name	"Alice"	Returns 'Alice'
7	Assign value	state.count	5	state.count set to 5
8	Assign value	state.active	True	state.active set to True
9	Access value	state.count	5	Returns 5
10	Access value	state.active	True	Returns True
11	Assign wrong type	state.count	"five"	Error or type mismatch
12	End	-	-	State schema enforces types; invalid assignment rejected

💡 Execution stops because the schema enforces types and rejects invalid assignments.

Variable Tracker

Variable	Start	After 5	After 7	After 8	Final
state.user_name	undefined	"Alice"	"Alice"	"Alice"	"Alice"
state.count	undefined	undefined	5	5	5
state.active	undefined	undefined	undefined	True	True

Key Moments - 2 Insights

Why does assigning a string to state.count cause an error?

Because the schema defines count as an int type, assigning a string violates the type rule, as shown in step 11 of the execution_table.

Can we access state fields before assigning values?

No, fields start undefined until assigned, as seen in variable_tracker where initial values are undefined.

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what value is assigned to state.user_name?

A undefined

B "Bob"

C "Alice"

D 5

💡 Hint

Check the 'Value/Type' column at step 5 in execution_table.

At which step does the schema reject an invalid type assignment?

A Step 7

B Step 11

C Step 3

D Step 9

💡 Hint

Look for the step mentioning 'Error or type mismatch' in execution_table.

If we set state.active to False instead of True at step 8, what changes in variable_tracker?

A state.active would be False after step 8

B state.active would remain undefined

C state.active would cause an error

D state.active would be True anyway

💡 Hint

Refer to variable_tracker row for state.active and consider assignment effects.

Concept Snapshot

State schema definition in langchain:
- Define fields with types inside State()
- Create a State object with these fields
- Assign values matching the declared types
- Access values via state.field_name
- Schema enforces type safety, rejects wrong types

Full Transcript

This visual execution trace shows how to define a state schema in langchain by specifying fields and their types. We create a State object with fields user_name as string, count as integer, and active as boolean. Assigning values to these fields updates the state. Accessing fields returns their current values. The schema enforces type safety, so assigning a wrong type like a string to count causes an error. The variable tracker shows how each field changes over time. Key moments clarify why type enforcement matters and when fields start undefined. The quiz tests understanding of assignments, errors, and state changes.

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