16. Session, State & Memory

# Create and activate virtual environment
python3 -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install dependencies
pip install google-adk python-dotenv

# Set our API key
export GOOGLE_API_KEY=our_api_key_here

import asyncio
from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types

# Create the agent
agent = Agent(
    model="gemini-2.5-flash",
    name="memory_agent",
    instruction="You are a helpful assistant. Remember what the user tells you.",
)

# Create session service and runner
session_service = InMemorySessionService()
runner = Runner(agent=agent, app_name="memory_app", session_service=session_service)

async def chat(user_id: str, session_id: str, message: str):
    """Send a message and get a response."""
    content = types.Content(role="user", parts=[types.Part(text=message)])
    
    response_text = ""
    async for event in runner.run_async(
        user_id=user_id,
        session_id=session_id,
        new_message=content
    ):
        if hasattr(event, 'content') and event.content and event.content.parts:
            for part in event.content.parts:
                if hasattr(part, 'text') and part.text:
                    response_text += part.text
    
    return response_text

async def main():
    user_id = "user_alice"
    
    # Create a session first (required!)
    session = await session_service.create_session(
        app_name="memory_app",
        user_id=user_id,
    )
    session_id = session.id
    
    print(f"User ID: {user_id}")
    print(f"Session ID: {session_id[:8]}...")
    print("-" * 40)
    
    # Multi-turn conversation - agent remembers context
    print("\nUser: Hi! My name is Alice and I'm looking for birthday gifts.")
    response = await chat(user_id, session_id, "Hi! My name is Alice and I'm looking for birthday gifts.")
    print(f"Agent: {response}\n")
    
    print("User: What's my name and what am I shopping for?")
    response = await chat(user_id, session_id, "What's my name and what am I shopping for?")
    print(f"Agent: {response}")

if __name__ == "__main__":
    asyncio.run(main())

from google.adk.agents import Agent
from google.adk.tools import ToolContext

def add_to_cart(item: str, quantity: int, tool_context: ToolContext) -> dict:
    """
    Add an item to the shopping cart.
    
    Args:
        item (str): The item name to add.
        quantity (int): Number of items to add.
        tool_context (ToolContext): The tool context with session access.
    
    Returns:
        dict: Confirmation of the added item.
    """
    state = tool_context.state
    
    # Initialize cart if not exists
    if "cart" not in state:
        state["cart"] = {}
    
    # Add item to cart
    if item in state["cart"]:
        state["cart"][item] += quantity
    else:
        state["cart"][item] = quantity
    
    return {
        "status": "success",
        "message": f"Added {quantity} {item}(s) to cart",
        "cart": state["cart"]
    }

def get_cart(tool_context: ToolContext) -> dict:
    """Get the current shopping cart contents."""
    state = tool_context.state
    cart = state.get("cart", {})
    return {"cart": cart, "total_items": sum(cart.values()) if cart else 0}

def clear_cart(tool_context: ToolContext) -> dict:
    """Clear all items from the shopping cart."""
    state = tool_context.state
    state["cart"] = {}
    return {"status": "success", "message": "Cart cleared"}

root_agent = Agent(
    model="gemini-2.5-flash",
    name="shopping_assistant",
    instruction="""You are a helpful shopping assistant. You can:
1. Remember what users tell you during the conversation (Session)
2. Manage a shopping cart using add_to_cart, get_cart, clear_cart (State)
Be friendly and helpful.""",
    tools=[add_to_cart, get_cart, clear_cart],
)

import asyncio
from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.adk.tools import ToolContext
from google.genai import types

# Shopping cart tools
def add_to_cart(item: str, quantity: int, tool_context: ToolContext) -> dict:
    """Add an item to the shopping cart."""
    state = tool_context.state
    if "cart" not in state:
        state["cart"] = {}
    if item in state["cart"]:
        state["cart"][item] += quantity
    else:
        state["cart"][item] = quantity
    return {"status": "success", "message": f"Added {quantity} {item}(s)", "cart": state["cart"]}

def get_cart(tool_context: ToolContext) -> dict:
    """Get current cart contents."""
    state = tool_context.state
    cart = state.get("cart", {})
    return {"cart": cart, "total_items": sum(cart.values()) if cart else 0}

# Create agent with tools
root_agent = Agent(
    model="gemini-2.5-flash",
    name="shopping_assistant",
    instruction="You are a shopping assistant. Help users manage their cart.",
    tools=[add_to_cart, get_cart],
)

# Initialize services
session_service = InMemorySessionService()
runner = Runner(agent=root_agent, app_name="shopping_app", session_service=session_service)

async def chat(user_id: str, session_id: str, message: str) -> str:
    """Send a message and get a response."""
    content = types.Content(role="user", parts=[types.Part(text=message)])
    response_text = ""
    async for event in runner.run_async(user_id=user_id, session_id=session_id, new_message=content):
        if hasattr(event, 'content') and event.content and event.content.parts:
            for part in event.content.parts:
                if hasattr(part, 'text') and part.text:
                    response_text += part.text
    return response_text

async def main():
    # DEMO 1: Session - Conversation Memory
    print("=" * 50)
    print("DEMO 1: SESSION - Conversation Memory")
    print("=" * 50)
    
    user_id = "user_alice"
    session = await session_service.create_session(app_name="shopping_app", user_id=user_id)
    
    print(f"\nUser ID: {user_id}")
    print(f"Session ID: {session.id[:8]}...")
    
    print("\nUser: Hi! My name is Alice.")
    response = await chat(user_id, session.id, "Hi! My name is Alice.")
    print(f"Agent: {response}")
    
    print("\nUser: Add 2 books and 3 candles to my cart")
    response = await chat(user_id, session.id, "Add 2 books and 3 candles to my cart")
    print(f"Agent: {response}")
    
    print("\nUser: What's in my cart?")
    response = await chat(user_id, session.id, "What's in my cart?")
    print(f"Agent: {response}")
    
    # DEMO 2: New Session - Cart Resets
    print("\n" + "=" * 50)
    print("DEMO 2: NEW SESSION - Cart Resets")
    print("=" * 50)
    
    new_session = await session_service.create_session(app_name="shopping_app", user_id=user_id)
    print(f"\nSame User: {user_id}")
    print(f"NEW Session ID: {new_session.id[:8]}...")
    
    print("\nUser: What's in my cart?")
    response = await chat(user_id, new_session.id, "What's in my cart?")
    print(f"Agent: {response}")
    print("(Cart is empty - state resets with new session!)")

if __name__ == "__main__":
    asyncio.run(main())

from google.adk.memory import InMemoryMemoryService

# Create memory service
memory_service = InMemoryMemoryService()

# Create runner with both session and memory services
runner = Runner(
    agent=agent,
    app_name="memory_app",
    session_service=session_service,
    memory_service=memory_service
)

# Memory is automatically populated from completed sessions
# and can be searched by the agent for relevant context

from google.adk.agents import Agent
from google.adk.tools.preload_memory_tool import PreloadMemoryTool

agent = Agent(
    model="gemini-2.5-flash",
    name="memory_agent",
    instruction="You are a helpful assistant that remembers past conversations.",
    tools=[PreloadMemoryTool()]
)

from google.adk.memory import VertexAiMemoryBankService

memory_service = VertexAiMemoryBankService(
    project="PROJECT_ID",
    location="LOCATION",
    agent_engine_id="AGENT_ENGINE_ID"
)

runner = Runner(
    agent=agent,
    app_name="memory_app",
    session_service=session_service,
    memory_service=memory_service
)