got Feature 0 working

docs/Phase 1/Task 1.3 Memory & Persona Implementation.md

@@ -189,10 +189,49 @@ The user will execute **one step at a time** and confirm each works before proce
 
 ---
 
-### 7 │ Documentation Update
+### 7 │ Changing App Responses to Provide User Personalization
 
-* Explain *why* the simple, surgical approach avoided regressions.
-* Update project docs to reflect the new persona‑memory workflow.
+* Review the context provided as Zep memoery in the zep_test.py file
+* create an LLM function to summarize this information into concise and declarative content, e.g. TELL THE 49ers FAN APP how to personalize its outgoing messages to deliver exactly the kind of content and experience this fan is looking for! 
+* review the structure of gradio_agent.py and identify where and how the AI agent can receive the instructions to personalize, using the  Minimal Surgical Changes rule
+* present the plan to the user and explain your rationale in detail. Prepare to debate and be open to new ideas
+* once a plan has been reviewed and approved, execute along the lines of the Appendix - First Principles in Action 
+
+**Status Update:**
+✅ Successfully reviewed the Zep memory contexts for both personas:
+   - Casual Fan persona has surface-level knowledge and is motivated by feeling included
+   - Super Fan persona has detailed knowledge and is motivated by strategic understanding
+✅ Created a new `get_persona_instructions()` function in gradio_agent.py to return different instructions based on the current persona
+✅ Updated prompts.py to include a placeholder for persona-specific instructions
+✅ Modified generate_response() to incorporate persona instructions into the agent prompt
+✅ Implemented two surgical changes to enhance persona-specific behavior:
+   - Enhanced persona instructions with more directive language and specific examples
+   - Added persona tag emphasizers around instructions and in user inputs
+
+**Implementation Details:**
+1. **Made Instructions More Direct and Prescriptive**:
+   - Rewritten instructions using "YOU MUST" language instead of suggestions
+   - Added numbered lists of specific behaviors to exhibit for each persona
+   - Included concrete examples of how responses should look for each persona
+   - Added "do/don't" sections to clarify expectations
+
+2. **Enhanced Instruction Visibility in the Agent Context**:
+   - Added emphasis tags around persona instructions: `[ACTIVE PERSONA: {current_persona}]`
+   - Added persona-specific prefix to user inputs: `[RESPOND AS {current_persona.upper()}]:`
+   - These small but effective changes helped ensure the instructions weren't lost in context
+
+**Results:**
+✅ Successfully implemented personalization with distinctly different responses for each persona:
+   - **Casual Fan responses** became shorter, used inclusive "we/our" language, included excitement markers (exclamation points), and focused on big moments and star players
+   - **Super Fan responses** became more detailed, used technical terminology, included structured analysis, and referenced role players alongside stars
+   - Example: When asked about draft news, the casual fan received a brief, excited summary focusing on star players and big moments, while the super fan received a detailed, categorized analysis with specific prospect evaluations
+
+**Future Improvements (Backlog):**
+- Further enhance personalization by integrating more facts from the Zep memory context into responses
+- Create a more sophisticated prompt that explicitly references relevant facts based on the current query
+- Add a mechanism to track and adapt to the user's knowledge level over time
+- Implement a feedback loop where users can indicate if responses are appropriately personalized
+- Explore ways to make persona-specific language settings persistent across sessions
 
 ---
 
@@ -234,6 +273,8 @@ The user will execute **one step at a time** and confirm each works before proce
 | Rigorous Testing | Test changes immediately after implementation to catch issues early | Ran the application after adding the radio button to verify it works |
 | Clear Documentation | Document design decisions and patterns | Added comments explaining why global variables are declared before functions that use them |
 | Consistent Logging | Use consistent prefixes for log messages to aid debugging | Added prefixes like "[PERSONA CHANGE]" and "[MEMORY LOAD]" |
+| Sequential Approval Workflow | Present detailed plans, wait for explicit approval on each component, implement one change at a time, and provide clear explanations of data flows | Explained how the persona instructions flow from selection to prompt generation before implementing changes |
+| Surgical Diff Principle | Show only the specific changes being made rather than reprinting entire code blocks | Highlighted just the 2 key modifications to implement personalization rather than presenting a large code block |
 
 ---
 

gradio_agent.py

@@ -155,6 +155,51 @@ def get_memory(session_id):
         # No memory_type parameter
     )
 
+# New function to generate persona-specific instructions
+def get_persona_instructions():
+    """Generate personalized instructions based on current persona"""
+    if current_persona == "Casual Fan":
+        return """
+PERSONA DIRECTIVE: CASUAL FAN MODE - YOU MUST FOLLOW THESE RULES
+
+YOU MUST speak to a casual 49ers fan with surface-level knowledge. This means you MUST:
+1. Keep explanations BRIEF and under 3-4 sentences whenever possible
+2. Use EVERYDAY LANGUAGE instead of technical football terms
+3. EMPHASIZE exciting plays, scoring, and player personalities
+4. FOCUS on "big moments" and "highlight-reel plays" in your examples
+5. AVOID detailed strategic analysis or technical football concepts
+6. CREATE a feeling of inclusion by using "we" and "our team" language
+7. INCLUDE at least one exclamation point in longer responses to convey excitement!
+
+Casual fans don't know or care about: blocking schemes, defensive alignments, or salary cap details.
+Casual fans DO care about: star players, touchdowns, big hits, and feeling connected to the team.
+
+EXAMPLE RESPONSE FOR CASUAL FAN (about the draft):
+"The 49ers did a great job finding exciting new players in the draft! They picked up a speedy receiver who could make some highlight-reel plays for us next season. The team focused on adding talent that can make an immediate impact, which is exactly what we needed!"
+"""
+    elif current_persona == "Super Fan":
+        return """
+PERSONA DIRECTIVE: SUPER FAN MODE - YOU MUST FOLLOW THESE RULES
+
+YOU MUST speak to a die-hard 49ers super fan with detailed football knowledge. This means you MUST:
+1. Provide DETAILED analysis that goes beyond surface-level information
+2. Use SPECIFIC football terminology and scheme concepts confidently
+3. REFERENCE role players and their contributions, not just star players
+4. ANALYZE strategic elements of plays, drafts, and team construction
+5. COMPARE current scenarios to historical team contexts when relevant
+6. INCLUDE specific stats, metrics, or technical details in your analysis
+7. ACKNOWLEDGE the complexity of football decisions rather than simplifying
+
+Super fans expect: scheme-specific analysis, salary cap implications, and detailed player evaluations.
+Super fans value: strategic insights, historical context, and acknowledgment of role players.
+
+EXAMPLE RESPONSE FOR SUPER FAN (about the draft):
+"The 49ers' draft strategy reflected their commitment to Shanahan's outside zone running scheme while addressing defensive depth issues. Their 3rd round selection provides versatility in the secondary with potential for both slot corner and safety roles, similar to how they've historically valued positional flexibility. The late-round offensive line selections show a continuing emphasis on athletic linemen who excel in zone blocking rather than power schemes, though they'll need development in pass protection techniques to become three-down players."
+"""
+    else:
+        # Default case - should not happen, but provides a fallback
+        return ""
+
 # Create the agent prompt
 agent_prompt = PromptTemplate.from_template(AGENT_SYSTEM_PROMPT)
 
@@ -226,20 +271,47 @@ def generate_response(user_input, session_id=None):
     Returns:
         dict: The full response object from the agent
     """
-    print('Starting generate_response function...')
-    print(f'User input: {user_input}')
-    print(f'Session ID: {session_id}')
+    print('[RESPONSE GEN] Starting generate_response function...')
+    print(f'[RESPONSE GEN] User input: {user_input}')
+    print(f'[RESPONSE GEN] Session ID: {session_id}')
+    print(f'[RESPONSE GEN] Current persona: {current_persona}')
 
     if not session_id:
         session_id = get_session_id()
-        print(f'Generated new session ID: {session_id}')
+        print(f'[RESPONSE GEN] Generated new session ID: {session_id}')
     
     # Initialize memory with Zep history
     memory = initialize_memory_from_zep(session_id)
     
-    # Create an agent executor with memory for this session
+    # DEBUG: Print conversation memory content
+    print(f"[DEBUG MEMORY] Memory type: {type(memory)}")
+    if hasattr(memory, 'chat_memory') and hasattr(memory.chat_memory, 'messages'):
+        print(f"[DEBUG MEMORY] Number of messages: {len(memory.chat_memory.messages)}")
+        for idx, msg in enumerate(memory.chat_memory.messages):
+            print(f"[DEBUG MEMORY] Message {idx}: {msg.type} - {msg.content[:100]}...")
+    
+    # Get persona-specific instructions for the prompt
+    persona_instructions = get_persona_instructions()
+    print(f'[RESPONSE GEN] Using persona instructions for: {current_persona}')
+    
+    # DEBUG: Print the persona instructions being used
+    print(f"[DEBUG INSTRUCTIONS] Persona instructions:\n{persona_instructions}")
+    
+    # Create a personalized prompt by modifying the template with the current persona instructions
+    # Keep the original prompt format but insert the persona instructions at the appropriate place
+    persona_tag = f"[ACTIVE PERSONA: {current_persona}]"
+    highlighted_instructions = f"{persona_tag}\n\n{persona_instructions}\n\n{persona_tag}"
+    agent_system_prompt_with_persona = AGENT_SYSTEM_PROMPT.replace(
+        "{persona_instructions}", highlighted_instructions
+    )
+    personalized_prompt = PromptTemplate.from_template(agent_system_prompt_with_persona)
+    
+    # Create a personalized agent with the updated prompt
+    personalized_agent = create_react_agent(agent_llm, tools, personalized_prompt)
+    
+    # Create an agent executor with memory for this session and personalized prompt
     session_agent_executor = AgentExecutor(
-        agent=agent,
+        agent=personalized_agent,
         tools=tools,
         verbose=True,
         memory=memory,  # Use the memory we initialized
@@ -253,7 +325,9 @@ def generate_response(user_input, session_id=None):
         try:
             print('Invoking session agent executor...')
             # The agent will now have access to the loaded history
-            response = session_agent_executor.invoke({"input": user_input})
+            persona_prefix = f"[RESPOND AS {current_persona.upper()}]: "
+            augmented_input = f"{persona_prefix}{user_input}"
+            response = session_agent_executor.invoke({"input": augmented_input})
             
             # Extract the output and format it for Streamlit
             if isinstance(response, dict):

prompts.py

@@ -6,6 +6,8 @@ Do not answer any questions that do not relate to the 49ers, players, or fans.
 
 Do not answer any questions using your pre-trained knowledge, only use the information provided in the context.
 
+{persona_instructions}
+
 **IMPORTANT RESPONSE FORMATTING:**
 - When you use a tool that generates a visual component (like "Game Recap" or "Player Information Search"), your final text answer should *only* contain the summary text.
 - Do NOT include Markdown for images (like `![...](...)`), links, or other elements that are already visually represented by the component. The visual component will be displayed separately.

z_utils/zep_test.py

@@ -4,6 +4,7 @@ This follows step 2 of Task 1.3 Memory & Persona Implementation.
 """
 import os
 import json
+import argparse
 from dotenv import load_dotenv
 from zep_cloud.client import Zep
 from langchain_core.messages import HumanMessage, AIMessage
@@ -19,11 +20,6 @@ if not ZEP_API_KEY:
 # Initialize Zep client
 zep = Zep(api_key=ZEP_API_KEY)
 
-# Use one of the session IDs from the task document
-# Casual fan: 241b3478c7634492abee9f178b5341cb
-# Super fan: dedcf5cb0d71475f976f4f66d98d6400
-SESSION_ID = "241b3478c7634492abee9f178b5341cb"  # Using Casual fan session ID
-
 def retrieve_chat_history(session_id):
     """
     Retrieve chat history for a specific session from Zep.
@@ -71,10 +67,19 @@ def get_zep_history(session_id):
         return []
 
 def main():
-    print(f"Retrieving chat history for session ID: {SESSION_ID}")
+    # Set up command line argument parsing
+    parser = argparse.ArgumentParser(description='Retrieve chat history from Zep')
+    parser.add_argument('--session_id', type=str, 
+                        default="241b3478c7634492abee9f178b5341cb",
+                        help='Session ID to retrieve (default: Casual Fan)')
+    args = parser.parse_args()
+    
+    session_id = args.session_id
+    
+    print(f"Retrieving chat history for session ID: {session_id}")
     
     # Get the memory for the session
-    memory = retrieve_chat_history(SESSION_ID)
+    memory = retrieve_chat_history(session_id)
     
     if memory:
         print("\n===== MEMORY CONTEXT =====")