Skip to main content

Scenario

A customer support agent that:
  • Remembers conversation context within a session
  • Learns about customers across sessions
  • Provides personalized support based on user profile

Complete Implementation

from upsonic import Agent, Task
from upsonic.storage.memory import Memory
from upsonic.storage.sqlite import SqliteStorage

# 1. Create persistent storage
storage = SqliteStorage(db_file="./support.db")

# 2. Configure memory with all features
memory = Memory(
    storage=storage,
    session_id="support_001",
    user_id="customer_123",
    full_session_memory=True,      # Remember conversation
    summary_memory=True,           # Generate summaries
    user_analysis_memory=True,     # Learn about customer
    num_last_messages=10,          # Keep last 10 turns
    model="openai/gpt-4o"
)

# 3. Create support agent
agent = Agent(
    model="openai/gpt-4o",
    name="Support Agent",
    memory=memory
)

# 4. First interaction
result1 = agent.do(Task("I'm having trouble logging in to my account"))
print("Response 1:", result1)

# 5. Follow-up - agent remembers context
result2 = agent.do(Task("I tried resetting my password but didn't get the email"))
print("Response 2:", result2)

# 6. Agent references previous context
result3 = agent.do(Task("What have I told you about my issue?"))
print("Response 3:", result3)

Cross-Session Memory

Same customer returns in a new session:
from upsonic import Agent, Task
from upsonic.storage.memory import Memory
from upsonic.storage.sqlite import SqliteStorage

# Same storage instance or connection to same db file
storage = SqliteStorage(db_file="./support.db")

# New session, same customer
memory = Memory(
    storage=storage,
    session_id="support_002",       # NEW session
    user_id="customer_123",          # SAME customer
    full_session_memory=True,
    user_analysis_memory=True,
    model="openai/gpt-4o"
)

agent = Agent("openai/gpt-4o", memory=memory)

# Agent knows customer from previous sessions
result = agent.do(Task("Hello, I'm back. What did we discuss before?"))
print(result)

Async Usage

import asyncio
from upsonic import Agent, Task
from upsonic.storage.memory import Memory
from upsonic.storage.sqlite import SqliteStorage

async def main():
    storage = SqliteStorage(db_file="./async_support.db")
    
    memory = Memory(
        storage=storage,
        session_id="async_001",
        user_id="user_456",
        full_session_memory=True,
        summary_memory=True,
        model="openai/gpt-4o"
    )
    
    agent = Agent("openai/gpt-4o", memory=memory)
    
    # Async execution
    result1 = await agent.do_async(Task("My order hasn't arrived"))
    result2 = await agent.do_async(Task("It's been 5 days"))
    
    print("Final response:", result2)

asyncio.run(main())

What Gets Persisted

Session Table

FieldContent
session_id"support_001"
user_id"customer_123"
messagesFull conversation history
summaryGenerated session summary
runsIndividual run outputs

User Memory Table

FieldContent
user_id"customer_123"
user_memoryExtracted traits (login issues, communication style)

Key Takeaways

  1. Same storage, different sessions - User profile persists
  2. Memory is automatic - Just attach to agent, no manual saving
  3. Summary + History - Use both for best context/cost balance
  4. Sync and async - Both do() and do_async() work with memory