Merge pull request #17 from pamelafox/session2-tweaks

Tweak examples for session 2

Author: pamelafox

examples/agent_history_redis.py

@@ -63,7 +63,7 @@ async def example_persistent_session() -> None:
     session_id = str(uuid.uuid4())
 
     # Phase 1: Start a conversation with a Redis-backed history provider
-    print("[dim]--- Phase 1: Starting conversation ---[/dim]")
+    print("[bold]--- Phase 1: Starting conversation ---[/bold]")
     redis_provider = RedisHistoryProvider(source_id="redis_chat", redis_url=REDIS_URL)
 
     agent = Agent(
@@ -84,7 +84,7 @@ async def example_persistent_session() -> None:
     print(f"[green]Agent:[/green] {response.text}")
 
     # Phase 2: Simulate an application restart — reconnect using the same session ID in Redis
-    print("\n[dim]--- Phase 2: Resuming after 'restart' ---[/dim]")
+    print("\n[bold]--- Phase 2: Resuming after 'restart' ---[/bold]")
     redis_provider2 = RedisHistoryProvider(source_id="redis_chat", redis_url=REDIS_URL)
 
     agent2 = Agent(
@@ -99,7 +99,6 @@ async def example_persistent_session() -> None:
     print("[blue]User:[/blue] Which of the cities I asked about had better weather?")
     response = await agent2.run("Which of the cities I asked about had better weather?", session=session2)
     print(f"[green]Agent:[/green] {response.text}")
-    print("[dim]Note: The agent remembered the conversation from Phase 1 via Redis persistence.[/dim]")
 
 
 async def main() -> None:
@@ -111,17 +110,15 @@ async def main() -> None:
     try:
         r.ping()
     except Exception as e:
-        print(f"[red]Cannot connect to Redis at {REDIS_URL}: {e}[/red]")
-        print(
-            "[red]Ensure Redis is running (e.g. via the dev container"
-            " or 'docker run -p 6379:6379 redis:7-alpine').[/red]"
+        logger.error(f"Cannot connect to Redis at {REDIS_URL}: {e}")
+        logger.error(
+            "Ensure Redis is running (e.g. via the dev container"
+            " or 'docker run -p 6379:6379 redis:7-alpine')."
         )
         return
     finally:
         r.close()
 
-    print("[dim]Redis connection verified.[/dim]")
-
     await example_persistent_session()
 
     if async_credential:

examples/agent_history_sqlite.py

@@ -111,7 +111,7 @@ async def main() -> None:
 
     # Phase 1: Start a conversation with a SQLite-backed history provider
     print("\n[bold]=== Persistent SQLite Session ===[/bold]")
-    print("[dim]--- Phase 1: Starting conversation ---[/dim]")
+    print("[bold]--- Phase 1: Starting conversation ---[/bold]")
 
     sqlite_provider = SQLiteHistoryProvider(db_path=db_path)
 
@@ -132,12 +132,8 @@ async def main() -> None:
     response = await agent.run("How about Paris?", session=session)
     print(f"[green]Agent:[/green] {response.text}")
 
-    messages = await sqlite_provider.get_messages(session_id)
-    print(f"[dim]Messages stored in SQLite: {len(messages)}[/dim]")
-    sqlite_provider.close()
-
     # Phase 2: Simulate an application restart — reconnect to the same session ID in SQLite
-    print("\n[dim]--- Phase 2: Resuming after 'restart' ---[/dim]")
+    print("\n[bold]--- Phase 2: Resuming after 'restart' ---[/bold]")
     sqlite_provider2 = SQLiteHistoryProvider(db_path=db_path)
 
     agent2 = Agent(
@@ -152,7 +148,6 @@ async def main() -> None:
     print("[blue]User:[/blue] Which of the cities I asked about had better weather?")
     response = await agent2.run("Which of the cities I asked about had better weather?", session=session2)
     print(f"[green]Agent:[/green] {response.text}")
-    print("[dim]Note: The agent remembered the conversation from Phase 1 via SQLite persistence.[/dim]")
 
     sqlite_provider2.close()
 

examples/agent_knowledge_pg_rewrite.py

@@ -411,9 +411,6 @@ async def main() -> None:
     like "protective jackets and boots for hiking in snow".
     """
     print("\n[bold]=== Knowledge Retrieval with Query Rewriting ===[/bold]")
-    print("[dim]In multi-turn conversations, the LLM rewrites the search query[/dim]")
-    print("[dim]using full conversation context for better retrieval.[/dim]\n")
-
     session = agent.create_session()
 
     # Turn 1: User asks about rain protection on rocky paths

examples/agent_knowledge_postgres.py

@@ -342,24 +342,13 @@ def setup_db() -> psycopg.Connection:
 async def main() -> None:
     """Demonstrate hybrid search RAG with several queries."""
     print("\n[bold]=== Knowledge Retrieval (RAG) with PostgreSQL Hybrid Search ===[/bold]")
-    print("[dim]The agent uses pgvector (semantic) + tsvector (keyword) with RRF before each LLM call.[/dim]\n")
 
     # Query 1: Should match hiking boots and trekking poles
     print("[blue]User:[/blue] I'm planning a hiking trip. What boots and poles do you recommend?")
     response = await agent.run("I'm planning a hiking trip. What boots and poles do you recommend?")
     print(f"[green]Agent:[/green] {response.text}\n")
 
-    # Query 2: Should match the down jacket
-    print("[blue]User:[/blue] I need something warm for winter camping, maybe a jacket?")
-    response = await agent.run("I need something warm for winter camping, maybe a jacket?")
-    print(f"[green]Agent:[/green] {response.text}\n")
-
-    # Query 3: Should match the kayak paddle (semantic match — "water sports gear")
-    print("[blue]User:[/blue] What water sports gear do you carry?")
-    response = await agent.run("What water sports gear do you carry?")
-    print(f"[green]Agent:[/green] {response.text}\n")
-
-    # Query 4: Semantic match — "gadgets for wildlife watching" → binoculars
+    # Query 2: Semantic match — "gadgets for wildlife watching" → binoculars
     print("[blue]User:[/blue] I want gadgets for wildlife watching")
     response = await agent.run("I want gadgets for wildlife watching")
     print(f"[green]Agent:[/green] {response.text}\n")

examples/agent_knowledge_sqlite.py

@@ -294,23 +294,12 @@ async def main() -> None:
     """Demonstrate the knowledge retrieval (RAG) pattern with several queries."""
     # Query 1: Should match hiking boots and trekking poles
     print("\n[bold]=== Knowledge Retrieval (RAG) Demo ===[/bold]")
-    print("[dim]The agent searches a SQLite FTS5 knowledge base before each LLM call.[/dim]\n")
 
     print("[blue]User:[/blue] I'm planning a hiking trip. What boots and poles do you recommend?")
     response = await agent.run("I'm planning a hiking trip. What boots and poles do you recommend?")
     print(f"[green]Agent:[/green] {response.text}\n")
 
-    # Query 2: Should match the down jacket
-    print("[blue]User:[/blue] I need something warm for winter camping, maybe a jacket?")
-    response = await agent.run("I need something warm for winter camping, maybe a jacket?")
-    print(f"[green]Agent:[/green] {response.text}\n")
-
-    # Query 3: Should match the kayak paddle
-    print("[blue]User:[/blue] Do you sell anything for kayaking?")
-    response = await agent.run("Do you sell anything for kayaking?")
-    print(f"[green]Agent:[/green] {response.text}\n")
-
-    # Query 4: No match expected — demonstrates graceful "no knowledge" handling
+    # Query 2: No match expected — demonstrates graceful "no knowledge" handling
     print("[blue]User:[/blue] Do you have any surfboards?")
     response = await agent.run("Do you have any surfboards?")
     print(f"[green]Agent:[/green] {response.text}\n")

examples/agent_memory_mem0.py

@@ -110,11 +110,31 @@ async def main() -> None:
                 },
             },
         }
+    elif API_HOST == "github":
+        # Use GitHub Models for both Mem0's LLM and embedder
+        mem0_config = {
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": os.getenv("GITHUB_MODEL", "openai/gpt-4.1-mini"),
+                    "api_key": os.environ["GITHUB_TOKEN"],
+                    "openai_base_url": "https://models.github.ai/inference",
+                },
+            },
+            "embedder": {
+                "provider": "openai",
+                "config": {
+                    "model": "openai/text-embedding-3-small",
+                    "api_key": os.environ["GITHUB_TOKEN"],
+                    "openai_base_url": "https://models.github.ai/inference",
+                },
+            },
+        }
     elif os.getenv("OPENAI_API_KEY"):
         mem0_config = {}  # Mem0 defaults to OpenAI via OPENAI_API_KEY
     else:
-        print("[red]Mem0 OSS requires an LLM for memory extraction.[/red]")
-        print("[red]Set API_HOST=azure (with Azure OpenAI) or set OPENAI_API_KEY.[/red]")
+        logger.error("Mem0 OSS requires an LLM for memory extraction.")
+        logger.error("Set API_HOST=azure (with Azure OpenAI) or set OPENAI_API_KEY.")
         return
 
     mem0_client = await AsyncMemory.from_config(mem0_config)
@@ -132,27 +152,25 @@ async def main() -> None:
     )
 
     # Step 1: Teach the agent user preferences
-    print("\n[dim]--- Step 1: Teaching preferences ---[/dim]")
+    print("\n[bold]--- Step 1: Teaching preferences ---[/bold]")
     print("[blue]User:[/blue] Remember that my favorite city is Tokyo and I prefer Celsius.")
     response = await agent.run("Remember that my favorite city is Tokyo and I prefer Celsius.")
     print(f"[green]Agent:[/green] {response.text}")
 
     # Step 2: Start a new session — Mem0 should inject remembered facts
-    print("\n[dim]--- Step 2: New session — recalling preferences ---[/dim]")
+    print("\n[bold]--- Step 2: New session — recalling preferences ---[/bold]")
     print("[blue]User:[/blue] What's my favorite city?")
     response = await agent.run("What's my favorite city?")
     print(f"[green]Agent:[/green] {response.text}")
-    print("[dim]Note: Mem0 extracted and stored facts, then injected them into the new session.[/dim]")
 
     # Step 3: Use a tool, demonstrating memory with tool outputs
-    print("\n[dim]--- Step 3: Tool use with memory ---[/dim]")
+    print("\n[bold]--- Step 3: Tool use with memory ---[/bold]")
     print("[blue]User:[/blue] What's the weather in my favorite city?")
     response = await agent.run("What's the weather in my favorite city?")
     print(f"[green]Agent:[/green] {response.text}")
-    print("[dim]Note: The agent used Mem0 memory to know which city to check.[/dim]")
 
     # Show what Mem0 has stored
-    print("\n[dim]--- Extracted memories ---[/dim]")
+    print("\n[bold]--- Extracted memories ---[/bold]")
     memories = await mem0_client.get_all(user_id=user_id)
     for mem in memories.get("results", []):
         print(f"  [cyan]•[/cyan] {mem.get('memory', '')}")

examples/agent_memory_redis.py

@@ -96,19 +96,19 @@ async def example_agent_with_memory() -> None:
     )
 
     # Step 1: Teach the agent a user preference
-    print("\n[dim]--- Step 1: Teaching a preference ---[/dim]")
+    print("\n[bold]--- Step 1: Teaching a preference ---[/bold]")
     print("[blue]User:[/blue] Remember that my favorite city is Tokyo.")
     response = await agent.run("Remember that my favorite city is Tokyo.")
     print(f"[green]Agent:[/green] {response.text}")
 
     # Step 2: Ask the agent to recall the preference from memory
-    print("\n[dim]--- Step 2: Recalling a preference ---[/dim]")
+    print("\n[bold]--- Step 2: Recalling a preference ---[/bold]")
     print("[blue]User:[/blue] What's my favorite city?")
     response = await agent.run("What's my favorite city?")
     print(f"[green]Agent:[/green] {response.text}")
 
     # Step 3: Use a tool, then verify the agent remembers tool output details
-    print("\n[dim]--- Step 3: Tool use with memory ---[/dim]")
+    print("\n[bold]--- Step 3: Tool use with memory ---[/bold]")
     print("[blue]User:[/blue] What's the weather in Paris?")
     response = await agent.run("What's the weather in Paris?")
     print(f"[green]Agent:[/green] {response.text}")
@@ -119,21 +119,6 @@ async def example_agent_with_memory() -> None:
 
 
 async def main() -> None:
-    """Run the Redis memory example."""
-    # Verify Redis has RediSearch module
-    import redis as redis_client
-
-    r = redis_client.from_url(REDIS_URL)
-    try:
-        r.execute_command("FT._LIST")
-    except Exception:
-        print(f"[red]Redis at {REDIS_URL} does not have the RediSearch module.[/red]")
-        return
-    finally:
-        r.close()
-
-    print("[dim]Redis Stack with RediSearch verified.[/dim]")
-
     await example_agent_with_memory()
 
     if async_credential:

examples/agent_session.py

@@ -62,15 +62,13 @@ async def example_without_session() -> None:
     """Without a session, each call is independent — the agent has no memory of prior messages."""
     print("\n[bold]=== Without Session (No Memory) ===[/bold]")
 
-    response = await agent.run("What's the weather like in Seattle?")
     print(f"[blue]User:[/blue] What's the weather like in Seattle?")
+    response = await agent.run("What's the weather like in Seattle?")
     print(f"[green]Agent:[/green] {response.text}")
 
-    response = await agent.run("What was the last city I asked about?")
     print(f"\n[blue]User:[/blue] What was the last city I asked about?")
+    response = await agent.run("What was the last city I asked about?")
     print(f"[green]Agent:[/green] {response.text}")
-    print("[dim]Note: Each call creates a separate session, so the agent doesn't remember previous context.[/dim]")
-
 
 async def example_with_session() -> None:
     """With a session, the agent maintains context across multiple messages."""
@@ -89,7 +87,6 @@ async def example_with_session() -> None:
     print(f"\n[blue]User:[/blue] Which of those cities has better weather?")
     response = await agent.run("Which of those cities has better weather?", session=session)
     print(f"[green]Agent:[/green] {response.text}")
-    print("[dim]Note: The agent remembers context from previous messages in the same session.[/dim]")
 
 
 async def example_session_across_agents() -> None:
@@ -112,7 +109,6 @@ async def example_session_across_agents() -> None:
     print(f"\n[blue]User:[/blue] What was the last city I asked about?")
     response = await agent2.run("What was the last city I asked about?", session=session)
     print(f"[green]Agent 2:[/green] {response.text}")
-    print("[dim]Note: The second agent continues the conversation using the session's message history.[/dim]")
 
 
 async def main() -> None:

examples/redis_viewer.py

@@ -8,7 +8,6 @@
 import redis
 from dotenv import load_dotenv
 from rich import print
-from rich.console import Group
 from rich.panel import Panel
 from rich.syntax import Syntax
 from rich.text import Text
@@ -57,34 +56,21 @@
 
     elif key_type == "list":
         items = r.lrange(key, 0, -1)
-        panels = []
-        for i, item in enumerate(items):
+        parts = []
+        for item in items:
             raw = item.decode()
             try:
-                parsed = json.loads(raw)
-                role = parsed.get("role", {}).get("value", "unknown")
-                contents = parsed.get("contents", [])
-                # Extract display text
-                parts = []
-                for c in contents:
-                    if c.get("type") == "text":
-                        parts.append(c["text"])
-                    elif c.get("type") == "function_call":
-                        parts.append(f"[tool call] {c['name']}({c['arguments']})")
-                    elif c.get("type") == "function_result":
-                        parts.append(f"[tool result] {c['result']}")
-                display = "\n".join(parts) if parts else json.dumps(parsed, indent=2)
-                color = {"user": "blue", "assistant": "green", "tool": "yellow"}.get(role, "white")
-                panels.append(
-                    Panel(display, title=f"[bold {color}]{role}[/bold {color}] [dim]({i + 1}/{len(items)})[/dim]")
-                )
+                formatted = json.dumps(json.loads(raw), indent=2)
             except json.JSONDecodeError:
-                panels.append(Panel(raw, title=f"[dim]item {i + 1}/{len(items)}[/dim]"))
+                formatted = raw
+            parts.append(formatted)
+        combined = "\n---\n".join(parts)
+        content = Syntax(combined, "json", theme="monokai", word_wrap=True)
         print(
             Panel(
-                Group(*panels),
+                content,
                 title=f"[bold cyan]{key}[/bold cyan] [dim]({key_type})[/dim]",
-                subtitle=f"[dim]{len(items)} message(s)[/dim]",
+                subtitle=f"[dim]{len(items)} item(s)[/dim]",
             )
         )
 

examples/spanish/agent_history_redis.py

@@ -63,7 +63,7 @@ async def example_persistent_session() -> None:
     session_id = str(uuid.uuid4())
 
     # Fase 1: Iniciar una conversación con un proveedor de historial en Redis
-    print("[dim]--- Fase 1: Iniciando conversación ---[/dim]")
+    print("[bold]--- Fase 1: Iniciando conversación ---[/bold]")
     redis_provider = RedisHistoryProvider(source_id="redis_chat", redis_url=REDIS_URL)
 
     agent = Agent(
@@ -84,7 +84,7 @@ async def example_persistent_session() -> None:
     print(f"[green]Agente:[/green] {response.text}")
 
     # Fase 2: Simular un reinicio de la app — reconectar usando el mismo session_id en Redis
-    print("\n[dim]--- Fase 2: Reanudando después del 'reinicio' ---[/dim]")
+    print("\n[bold]--- Fase 2: Reanudando después del 'reinicio' ---[/bold]")
     redis_provider2 = RedisHistoryProvider(source_id="redis_chat", redis_url=REDIS_URL)
 
     agent2 = Agent(
@@ -99,7 +99,6 @@ async def example_persistent_session() -> None:
     print("[blue]Usuario:[/blue] ¿Cuál de las ciudades por las que pregunté tuvo mejor clima?")
     response = await agent2.run("¿Cuál de las ciudades por las que pregunté tuvo mejor clima?", session=session2)
     print(f"[green]Agente:[/green] {response.text}")
-    print("[dim]Nota: El agente recordó la conversación de la Fase 1 gracias a la persistencia en Redis.[/dim]")
 
 
 async def main() -> None:
@@ -111,17 +110,15 @@ async def main() -> None:
     try:
         r.ping()
     except Exception as e:
-        print(f"[red]No se puede conectar a Redis en {REDIS_URL}: {e}[/red]")
-        print(
-            "[red]Asegúrate de que Redis esté corriendo (por ejemplo, con el dev container"
-            " o con 'docker run -p 6379:6379 redis:7-alpine').[/red]"
+        logger.error(f"No se puede conectar a Redis en {REDIS_URL}: {e}")
+        logger.error(
+            "Asegúrate de que Redis esté corriendo (por ejemplo, con el dev container"
+            " o con 'docker run -p 6379:6379 redis:7-alpine')."
         )
         return
     finally:
         r.close()
 
-    print("[dim]Conexión a Redis verificada.[/dim]")
-
     await example_persistent_session()
 
     if async_credential: