⚡ Advanced State Management in Gradio Chatbots
Building intelligent chat applications requires tracking more than just recent message turns. By leveraging Gradio's gr.State component and custom session structures, developers can maintain user preferences, manage authentication tokens, track shopping cart items across dialogue turns, and prune conversation histories to prevent LLM context window overflows.
Example 1: Definition & Basic gr.State Conversation Memory
Utilizes
gr.State to persist custom user metadata across multiple chat turns without exposing it directly in the UI.
Python (state_ex1.py)
import gradio as gr
def state_chat(message, history, user_state):
if not user_state:
user_state = {"visit_count": 1, "tier": "Standard"}
else:
user_state["visit_count"] += 1
reply = f"Hello! This is turn #{user_state['visit_count']} in your session. Your tier is {user_state['tier']}."
return reply, user_state
with gr.Blocks() as demo:
state_store = gr.State({})
chatbot = gr.ChatInterface(
fn=state_chat,
additional_inputs=[state_store],
title="Session State Tracker Chatbot"
)
if __name__ == "__main__":
demo.launch()
🖥️ Live Web UI Visual Output Preview
### Session State Tracker Chatbot
[Chat Feed: Hello! This is turn #2 in your session...]
Example 2: User Persona & Profile State Management
Maintains an active user profile state (Name, Language, Role) to customize chatbot responses dynamically.
Python (state_ex2.py)
import gradio as gr
def persona_chat(message, history, profile):
if not profile:
profile = {"name": "Nikita", "role": "Developer"}
if "my name is" in message.lower():
name = message.split("is")[-1].strip()
profile["name"] = name
return f"Nice to meet you, {name}! I have updated your profile state.", profile
return f"Hello {profile['name']} ({profile['role']}). How can I help your project today?", profile
with gr.Blocks() as demo:
profile_state = gr.State({})
gr.ChatInterface(
fn=persona_chat,
additional_inputs=[profile_state],
title="User Persona State Chatbot"
)
if __name__ == "__main__":
demo.launch()
🖥️ Live Web UI Visual Output Preview
### User Persona State Chatbot
Hello Nikita (Developer). How can I help your project today?
Example 3: Conversation History Trimming & Context Window Control
Automatically trims conversation history arrays to retain only the last N turns, preventing token overflow.
Python (state_ex3.py)
import gradio as gr
def trimmed_history_chat(message, history):
max_turns = 3
trimmed_history = history[-max_turns:] if len(history) > max_turns else history
return f"Active history window size: {len(trimmed_history)} turn(s) retained out of {len(history)} total turns.\n\nResponse to: '{message}'"
demo = gr.ChatInterface(
fn=trimmed_history_chat,
title="History Trimming & Context Manager"
)
if __name__ == "__main__":
demo.launch()
🖥️ Live Web UI Visual Output Preview
### History Trimming & Context Manager
Active history window size: 3 turn(s) retained out of 10 total turns.
Example 4: Multi-Turn Shopping Cart State Tracker
Accumulates items added by the user into a persistent cart dictionary stored across conversation turns.
Python (state_ex4.py)
import gradio as gr
def cart_chat(message, history, cart_state):
if cart_state is None:
cart_state = []
msg = message.lower()
if "add" in msg:
item = message.replace("add", "").strip()
cart_state.append(item)
return f"🛒 Added '{item}' to your cart. Current Cart: {cart_state}", cart_state
elif "cart" in msg:
return f"🛍️ Your Shopping Cart Items: {cart_state}", cart_state
return f"Type 'add [item]' to add products or 'cart' to view items. Current items: {cart_state}", cart_state
with gr.Blocks() as demo:
cart_store = gr.State([])
gr.ChatInterface(
fn=cart_chat,
additional_inputs=[cart_store],
title="Shopping Cart State Chatbot"
)
if __name__ == "__main__":
demo.launch()
🖥️ Live Web UI Visual Output Preview
### Shopping Cart State Chatbot
🛒 Added 'Nikita Web Template' to your cart. Current Cart: ['Nikita Web Template']
Example 5: Stateful Conversation Reset & Memory Clearing
Provides state reset mechanisms allowing users to clear conversation memory and start fresh sessions.
Python (state_ex5.py)
import gradio as gr
def reset_chat(message, history, counter):
if counter is None:
counter = 0
if message.lower() == "reset":
counter = 0
return "🔄 Session memory and counter reset successfully!", counter
counter += 1
return f"Turn counter: {counter}. Type 'reset' to clear state.", counter
with gr.Blocks() as demo:
count_state = gr.State(0)
gr.ChatInterface(
fn=reset_chat,
additional_inputs=[count_state],
title="State Reset & Memory Clear Chatbot"
)
if __name__ == "__main__":
demo.launch()
🖥️ Live Web UI Visual Output Preview
### State Reset & Memory Clear Chatbot
🔄 Session memory and counter reset successfully!
Example 6: Multi-Step Interactive Form State Machine
Tracks progression through a multi-step questionnaire (Step 1: Name ➔ Step 2: Email ➔ Step 3: Service).
Python (state_ex6.py)
import gradio as gr
def form_state_chat(message, history, form_state):
if form_state is None:
form_state = {"step": 1, "name": "", "email": ""}
if form_state["step"] == 1:
form_state["name"] = message
form_state["step"] = 2
return f"Thanks {message}! Now, please enter your email address:", form_state
elif form_state["step"] == 2:
form_state["email"] = message
form_state["step"] = 3
return f"Got your email: {message}. Finally, what service do you need (Web Design / AI)?", form_state
else:
return f"Form complete! Registered Name: {form_state['name']}, Email: {form_state['email']}, Service: {message}.", form_state
with gr.Blocks() as demo:
form_store = gr.State({})
gr.ChatInterface(
fn=form_state_chat,
additional_inputs=[form_store],
title="Multi-Step Form State Machine"
)
if __name__ == "__main__":
demo.launch()
🖥️ Live Web UI Visual Output Preview
### Multi-Step Form State Machine
Thanks Nikita! Now, please enter your email address:
Example 7: Persistent Session Storage with Server-Side State
Maintains robust server-side state dictionaries keyed by session identifiers across chat interactions.
Python (state_ex7.py)
import gradio as gr
SESSION_STORE = {}
def server_state_chat(message, history, request: gr.Request):
session_id = request.session_hash if request else "default"
if session_id not in SESSION_STORE:
SESSION_STORE[session_id] = {"chats": 0}
SESSION_STORE[session_id]["chats"] += 1
count = SESSION_STORE[session_id]["chats"]
return f"Session Hash: {session_id[:8]}... | Server-tracked interaction count: {count}"
demo = gr.ChatInterface(
fn=server_state_chat,
title="Server-Side Session State Tracker"
)
if __name__ == "__main__":
demo.launch()
🖥️ Live Web UI Visual Output Preview
### Server-Side Session State Tracker
Session Hash: 4a2f8b1c... | Server-tracked interaction count: 4
Example 8: Authentication & Role-Based Access State
Tracks login authentication status and user roles (Admin vs Guest) in conversation state.
Python (state_ex8.py)
import gradio as gr
def auth_chat(message, history, auth_state):
if auth_state is None:
auth_state = {"authenticated": False, "role": "Guest"}
if "login as admin" in message.lower():
auth_state = {"authenticated": True, "role": "Administrator"}
return "🔐 Authentication successful! Welcome, Administrator. Full privileges unlocked.", auth_state
role = auth_state["role"]
return f"Current Access Role: {role}. Type 'login as admin' to elevate privileges.", auth_state
with gr.Blocks() as demo:
auth_store = gr.State({})
gr.ChatInterface(
fn=auth_chat,
additional_inputs=[auth_store],
title="Role-Based Access State Chatbot"
)
if __name__ == "__main__":
demo.launch()
🖥️ Live Web UI Visual Output Preview
### Role-Based Access State Chatbot
🔐 Authentication successful! Welcome, Administrator. Full privileges unlocked.
Example 9: Stateful Analytics & Conversation Summary Generator
Dynamically aggregates chat metrics (total words, message frequency) into state objects.
Python (state_ex9.py)
import gradio as gr
def analytics_chat(message, history, stats):
if stats is None:
stats = {"total_words": 0, "messages": 0}
stats["messages"] += 1
stats["total_words"] += len(message.split())
return f"📊 **Session Analytics:**\n- Total Messages: {stats['messages']}\n- Total Words Typed: {stats['total_words']}", stats
with gr.Blocks() as demo:
stats_store = gr.State({})
gr.ChatInterface(
fn=analytics_chat,
additional_inputs=[stats_store],
title="Stateful Conversation Analytics Tracker"
)
if __name__ == "__main__":
demo.launch()
🖥️ Live Web UI Visual Output Preview
### Stateful Conversation Analytics Tracker
📊 Session Analytics:
- Total Messages: 5
- Total Words Typed: 42
- Total Messages: 5
- Total Words Typed: 42
Example 10: Enterprise Stateful Operations Hub (`gr.Blocks`)
Combines persistent state storage, interactive form controllers, and enterprise chat hubs using
gr.Blocks.
Python (state_ex10.py)
import gradio as gr
with gr.Blocks() as demo:
gr.Markdown("# 🚀 Enterprise Stateful Chat Operations Hub")
state_box = gr.State({"active_users": 1420, "system_mode": "Production"})
with gr.Row():
status_display = gr.Textbox(label="System State Panel", value="Mode: Production | Users: 1420")
gr.ChatInterface(
fn=lambda msg, hist, state: (f"Processed stateful request: '{msg}'. System Mode: {state.get('system_mode')}", state),
additional_inputs=[state_box],
title="Stateful Enterprise Chat"
)
if __name__ == "__main__":
demo.launch()
🖥️ Live Web UI Visual Output Preview
# 🚀 Enterprise Stateful Chat Operations Hub
Mode: Production | Users: 1420
[Interactive Stateful ChatInterface Box]