WIP implementation of team search, have improved component display of game and player search too

components/team_story_component.py

@@ -0,0 +1,63 @@
+"""
+Gradio component for displaying Team Story/News search results.
+"""
+
+import gradio as gr
+
+def create_team_story_component(team_story_data):
+    """
+    Creates a Gradio HTML component to display formatted team news articles.
+
+    Args:
+        team_story_data (list): A list of dictionaries, where each dictionary 
+                                  represents an article and contains keys like 
+                                  'summary', 'link_to_article', and 'topic'.
+
+    Returns:
+        gr.HTML: A Gradio HTML component containing the formatted news stories.
+                 Returns None if the input data is empty or invalid.
+    """
+    if not team_story_data or not isinstance(team_story_data, list):
+        return None # Return None if no data or invalid data
+
+    html_content = """<div style='padding: 15px; border: 1px solid #e0e0e0; border-radius: 5px; margin-top: 10px;'>
+                         <h3 style='margin-top: 0; margin-bottom: 10px;'>Recent Team News</h3>"""
+
+    for story in team_story_data:
+        if isinstance(story, dict):
+            summary = story.get('summary', 'No summary available.')
+            link = story.get('link_to_article', '#')
+            topic = story.get('topic', 'General')
+
+            # Sanitize link to prevent basic injection issues
+            safe_link = link if link.startswith(('http://', 'https://', '#')) else '#'
+            
+            # Escape basic HTML characters in text fields
+            def escape_html(text):
+                return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+            safe_summary = escape_html(summary)
+            safe_topic = escape_html(topic)
+
+            html_content += f"""<div style='margin-bottom: 15px; padding-bottom: 10px; border-bottom: 1px solid #eee;'>
+                                    <p style='font-size: 0.9em; color: #555; margin-bottom: 5px;'><strong>Topic:</strong> {safe_topic}</p>
+                                    <p style='margin-bottom: 8px;'>{safe_summary}</p>
+                                    <a href='{safe_link}' target='_blank' style='font-size: 0.9em;'>Read Full Article</a>
+                               </div>"""
+        else:
+            print(f"Warning: Skipping invalid item in team_story_data: {story}")
+
+    # Remove the last border-bottom if content was added
+    if len(team_story_data) > 0:
+         last_border_pos = html_content.rfind("border-bottom: 1px solid #eee;")
+         if last_border_pos != -1:
+              html_content = html_content[:last_border_pos] + html_content[last_border_pos:].replace("border-bottom: 1px solid #eee;", "")
+
+    html_content += "</div>"
+
+    # Return None if only the initial header was created (e.g., all items were invalid)
+    if html_content.strip() == """<div style='padding: 15px; border: 1px solid #e0e0e0; border-radius: 5px; margin-top: 10px;'>
+                         <h3 style='margin-top: 0; margin-bottom: 10px;'>Recent Team News</h3></div>""".strip():
+        return None
+
+    return gr.HTML(html_content) 

gradio_agent.py

@@ -20,8 +20,9 @@ from gradio_utils import get_session_id
 # Import tools
 from tools.cypher import cypher_qa_wrapper
 from tools.vector import get_game_summary
-from tools.game_recap import game_recap_qa
-from tools.player_search import player_search_qa # Import the new player search tool
+from tools.game_recap import game_recap_qa, get_last_game_data
+from tools.player_search import player_search_qa, get_last_player_data
+from tools.team_story import team_story_qa, get_last_team_story_data
 
 # Create a basic chat chain for general football discussion
 from langchain_core.prompts import ChatPromptTemplate
@@ -91,6 +92,13 @@ Examples: "Tell me about Brock Purdy", "Who is player number 97?", "Show me Nick
 Returns text summary and potentially visual card data.""",
         func=player_search_qa
     ),
+    Tool.from_function(
+        name="Team News Search",
+        description="""Use for questions about recent 49ers news, articles, summaries, or specific topics like 'draft' or 'roster moves'. 
+Examples: 'What's the latest team news?', 'Summarize recent articles about the draft', 'Any news about the offensive line?'
+Returns text summary and potentially structured article data.""",
+        func=team_story_qa
+    ),
     Tool.from_function(
         name="Game Recap",
         description="""Use SPECIFICALLY for detailed game recaps or when users want to see visual information about a particular game identified by opponent or date.

gradio_app.py

@@ -11,6 +11,7 @@ from gradio_llm import llm
 import gradio_utils
 from components.game_recap_component import create_game_recap_component
 from components.player_card_component import create_player_card_component
+from components.team_story_component import create_team_story_component
 
 # Import the Gradio-compatible agent instead of the original agent
 import gradio_agent
@@ -19,6 +20,7 @@ from gradio_agent import generate_response
 # Import cache getter functions
 from tools.game_recap import get_last_game_data
 from tools.player_search import get_last_player_data
+from tools.team_story import get_last_team_story_data
 
 # Define CSS directly
 css = """
@@ -286,20 +288,18 @@ with gr.Blocks(title="49ers FanAI Hub", theme=gr.themes.Soft(), css=css) as demo
     gr.Markdown("# 🏈 49ers FanAI Hub")
 
     # --- Component Display Area --- #
-    # Debug Textbox (Temporary)
-    debug_textbox = gr.Textbox(label="Debug Player Data", visible=True, interactive=False)
-    # Player card display (initially hidden)
-    player_card_display = gr.HTML(visible=False)
-    # Game recap display (initially hidden)
-    game_recap_display = gr.HTML(visible=False)
-
-    # Chat interface
+    # REMOVED Unused/Redundant Component Placeholders:
+    # debug_textbox = gr.Textbox(label="Debug Player Data", visible=True, interactive=False)
+    # player_card_display = gr.HTML(visible=False)
+    # game_recap_display = gr.HTML(visible=False)
+
+    # Chat interface - Components will be added directly here
     chatbot = gr.Chatbot(
         # value=state.get_chat_history(), # Let Gradio manage history display directly
         height=500,
         show_label=False,
         elem_id="chatbot",
-        # type="messages", # Default type often works better
+        # type="messages", # Using default tuple format as components are added
         render_markdown=True
     )
 
@@ -314,76 +314,92 @@ with gr.Blocks(title="49ers FanAI Hub", theme=gr.themes.Soft(), css=css) as demo
 
     # Define a combined function for user input and bot response
     async def process_and_respond(message, history):
-        print(f"History IN: {history}")
-        # Initialize if first interaction
-        if not state.initialized:
-            welcome_msg = await initialize_chat()
-            history = [(None, welcome_msg)] # Start history with welcome message
-            state.initialized = True
-            # Return immediately after initialization to show welcome message
-            # No component updates needed yet
-            return "", history, gr.update(visible=False), gr.update(visible=False), gr.update(value="")
-
-        # Append user message for processing & display
-        history.append((message, None))
-
-        # Process the message to get bot's text response
-        response_text = await process_message(message)
-
-        # Update last message in history with bot response
-        history[-1] = (message, response_text)
-        print(f"History OUT: {history}")
-
-        # --- Check Caches and Update Components --- #
-        # player_card_html = "" # No longer creating HTML directly here for player
-        player_card_visible = False
-        game_recap_html = ""
-        game_recap_visible = False
-        debug_text_update = gr.update(value="") # Default debug text update
-
-        # Check for Player Data first
-        player_data = get_last_player_data() # Check player cache
+        """Process user input, get agent response, check for components, and update history."""
+        
+        print(f"process_and_respond: Received message: {message}")
+        # history.append((message, None)) # Add user message placeholder
+        # yield "", history # Show user message immediately
+
+        # Call the agent to get the response (text output + potentially populates cached data)
+        agent_response = generate_response(message, state.session_id)
+        text_output = agent_response.get("output", "Sorry, something went wrong.")
+        metadata = agent_response.get("metadata", {})
+        tools_used = metadata.get("tools_used", ["None"])
+        
+        print(f"process_and_respond: Agent text output: {text_output}")
+        print(f"process_and_respond: Tools used: {tools_used}")
+
+        # Initialize response list with the text output
+        response_list = [(message, text_output)]
+
+        # Check for specific component data based on tools used or cached data
+        # Important: Call the getter functions *after* generate_response has run
+        
+        # Check for Player Card
+        player_data = get_last_player_data()
         if player_data:
-            print("Player data found in cache, updating debug textbox...")
-            # player_card_html = create_player_card_component(player_data) # Temporarily disable HTML generation
-            player_card_visible = False # Keep HTML hidden for now
-            debug_text_update = gr.update(value=str(player_data)) # Update debug textbox instead
-        else:
-            # If no player data, check for Game Data
-            game_data = get_last_game_data() # Check game cache
-            if game_data:
-                print("Game data found in cache, creating recap...")
-                game_recap_html = create_game_recap_component(game_data)
-                game_recap_visible = True
-            # No player data found, ensure debug text is cleared
-            debug_text_update = gr.update(value="")
-
-        # Return updates for all relevant components
-        # Note: player_card_display update is temporarily disabled (always hidden)
-        return (
-            "", 
-            history, 
-            debug_text_update, # Update for the debug textbox
-            gr.update(value="", visible=False), # Keep player HTML hidden
-            gr.update(value=game_recap_html, visible=game_recap_visible) # Update game recap as before
-        )
+            print(f"process_and_respond: Found player data: {player_data}")
+            player_card_component = create_player_card_component(player_data)
+            if player_card_component:
+                response_list.append((None, player_card_component))
+                print("process_and_respond: Added player card component.")
+            else:
+                 print("process_and_respond: Player data found but component creation failed.")
+
+        # Check for Game Recap
+        game_data = get_last_game_data()
+        if game_data:
+            print(f"process_and_respond: Found game data: {game_data}")
+            game_recap_comp = create_game_recap_component(game_data)
+            if game_recap_comp:
+                response_list.append((None, game_recap_comp))
+                print("process_and_respond: Added game recap component.")
+            else:
+                 print("process_and_respond: Game data found but component creation failed.")
+
+        # Check for Team Story --- NEW --- 
+        team_story_data = get_last_team_story_data()
+        if team_story_data:
+             print(f"process_and_respond: Found team story data: {team_story_data}")
+             team_story_comp = create_team_story_component(team_story_data)
+             if team_story_comp:
+                  response_list.append((None, team_story_comp))
+                  print("process_and_respond: Added team story component.")
+             else:
+                  print("process_and_respond: Team story data found but component creation failed.")
+                 
+        # Update history with all parts of the response (text + components)
+        # Gradio's Chatbot handles lists of (user, assistant) tuples, 
+        # where assistant can be text or a Gradio component.
+        # We replace the last entry (user, None) with the actual response items.
+        
+        # Gradio manages history display; we just return the latest exchange.
+        # The actual history state is managed elsewhere (e.g., Zep, Neo4j history)
+        
+        # Return the combined response list to update the chatbot UI
+        # The first element is user message + assistant text response
+        # Subsequent elements are None + UI component
+        print(f"process_and_respond: Final response list for UI: {response_list}")
+        # Return values suitable for outputs: [msg, chatbot]
+        return "", response_list # Return empty string for msg, list for chatbot
 
     # Set up event handlers with the combined function
     # Ensure outputs list matches the return values of process_and_respond
-    # Added debug_textbox to the outputs list
-    outputs_list = [msg, chatbot, debug_textbox, player_card_display, game_recap_display]
+    # REMOVED redundant components from outputs_list
+    outputs_list = [msg, chatbot]
     msg.submit(process_and_respond, [msg, chatbot], outputs_list)
     submit_btn.click(process_and_respond, [msg, chatbot], outputs_list)
 
     # Add a clear button
     clear_btn = gr.Button("Clear Conversation")
 
-    # Clear function - now needs to clear/hide components including debug box
+    # Clear function - now only needs to clear msg and chatbot
     def clear_chat():
-        return [], gr.update(value=""), gr.update(value="", visible=False), gr.update(value="", visible=False)
+        # Return empty values for msg and chatbot
+        return "", [] 
 
-    # Update clear outputs
-    clear_btn.click(clear_chat, None, [chatbot, debug_textbox, player_card_display, game_recap_display])
+    # Update clear outputs - only need msg and chatbot
+    clear_btn.click(clear_chat, None, [msg, chatbot])
 
 # Launch the app
 if __name__ == "__main__":

tools/team_story.py

@@ -0,0 +1,146 @@
+"""
+Tool for querying Neo4j about recent team news stories.
+"""
+
+import os
+import sys
+from dotenv import load_dotenv
+from langchain_core.prompts import PromptTemplate
+from langchain_openai import ChatOpenAI
+from langchain_community.chains.graph_qa.cypher import GraphCypherQAChain
+
+# Adjust path to import graph object and LLM from the parent directory
+parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+
+try:
+    from gradio_graph import graph  # Import the configured graph instance
+    from gradio_llm import llm  # Import the configured LLM instance
+except ImportError as e:
+    print(f"Error importing graph or llm: {e}")
+    print("Please ensure gradio_graph.py and gradio_llm.py exist and are configured correctly.")
+    sys.exit(1)
+
+# Load environment variables if needed (though graph/llm should be configured)
+load_dotenv()
+
+# Define the prompt for translating NL query to Cypher for Team Story
+CYPHER_TEAM_STORY_GENERATION_TEMPLATE = """
+Task: Generate Cypher query to query a graph database.
+Instructions:
+Use only the provided relationship types and properties in the schema.
+Do not use any other relationship types or properties that are not provided.
+Schema:
+{schema}
+Note: Do not include any explanations or apologies in your responses.
+Do not respond to any questions that might ask anything else than for you to construct a Cypher query.
+Do not include any text except the generated Cypher query.
+
+The question is:
+{query}
+
+Cypher Query:
+"""
+
+CYPHER_TEAM_STORY_GENERATION_PROMPT = PromptTemplate(
+    input_variables=["schema", "query"], template=CYPHER_TEAM_STORY_GENERATION_TEMPLATE
+)
+
+# Placeholder for structured data caching (similar to player_search/game_recap)
+LAST_TEAM_STORY_DATA = []
+
+def get_last_team_story_data():
+    """Returns the structured data from the last team story query."""
+    return LAST_TEAM_STORY_DATA
+
+def team_story_qa(query: str) -> dict:
+    """
+    Queries the Neo4j database for team news stories based on the user query.
+
+    Args:
+        query: The natural language query from the user.
+
+    Returns:
+        A dictionary containing the 'output' text and potentially structured 'team_story_data'.
+    """
+    global LAST_TEAM_STORY_DATA
+    LAST_TEAM_STORY_DATA = [] # Clear previous results
+
+    print(f"--- Running Team Story QA for query: {query} ---")
+
+    try:
+        # Initialize the QA chain for Team Story
+        team_story_chain = GraphCypherQAChain.from_llm(
+            llm=llm,                  # Use the pre-configured LLM
+            graph=graph,              # Use the pre-configured graph connection
+            cypher_prompt=CYPHER_TEAM_STORY_GENERATION_PROMPT,
+            verbose=True,             # Set to True for debugging Cypher generation
+            return_intermediate_steps=True, # Useful for debugging
+            return_direct=False # Return the final answer directly? Set to False for now
+        )
+        
+        # Use the GraphCypherQAChain to get results
+        # The chain handles NL -> Cypher -> Execution -> LLM response generation
+        result = team_story_chain.invoke({"query": query})
+        
+        print(f"Raw result from team_story_chain: {result}")
+
+        # Extract relevant info (summaries, links) from the result['intermediate_steps']
+        # This structure depends on GraphCypherQAChain's output
+        # Typically intermediate_steps contains context (list of dicts)
+        structured_results = []
+        if 'intermediate_steps' in result and isinstance(result['intermediate_steps'], list):
+            for step in result['intermediate_steps']:
+                if 'context' in step and isinstance(step['context'], list):
+                     for item in step['context']:
+                          # Assuming item is a dict representing a :Team_Story node
+                          if isinstance(item, dict):
+                            story_data = {
+                                'summary': item.get('s.summary', 'Summary not available'),
+                                'link_to_article': item.get('s.link_to_article', '#'),
+                                'topic': item.get('s.topic', 'Topic not available')
+                            }
+                            structured_results.append(story_data)
+
+        LAST_TEAM_STORY_DATA = structured_results
+        
+        # Format the text output
+        if not structured_results:
+             output_text = result.get('result', "I couldn't find any specific news articles matching your query, but I can try a broader search.")
+        else:
+             # Simple text formatting for now
+             output_text = result.get('result', "Here's what I found:") + "\n\n"
+             for i, story in enumerate(structured_results[:3]): # Show top 3
+                 output_text += f"{i+1}. {story['summary']}\n[Link: {story['link_to_article']}]\n\n"
+             if len(structured_results) > 3:
+                 output_text += f"... found {len(structured_results)} relevant articles in total."
+
+    except Exception as e:
+        print(f"Error during team_story_qa: {e}")
+        output_text = "Sorry, I encountered an error trying to find team news."
+        LAST_TEAM_STORY_DATA = []
+
+    print(f"--- Team Story QA output: {output_text} ---")
+    print(f"--- Team Story QA structured data: {LAST_TEAM_STORY_DATA} ---")
+    
+    # Return both text output and structured data (though structured data isn't used by agent yet)
+    return {"output": output_text, "team_story_data": LAST_TEAM_STORY_DATA}
+
+# Example usage (for testing)
+if __name__ == '__main__':
+    test_query = "What is the latest news about the 49ers draft?"
+    print(f"Testing team_story_qa with query: {test_query}")
+    response = team_story_qa(test_query)
+    print("\nResponse:")
+    print(response.get("output"))
+    print("\nStructured Data:")
+    print(response.get("team_story_data"))
+
+    test_query_2 = "Any updates on the roster?"
+    print(f"\nTesting team_story_qa with query: {test_query_2}")
+    response_2 = team_story_qa(test_query_2)
+    print("\nResponse:")
+    print(response_2.get("output"))
+    print("\nStructured Data:")
+    print(response_2.get("team_story_data"))