stage 1 of refactoring to gradio

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

GRADIO_README.md

@@ -0,0 +1,74 @@
+# 49ers FanAI Hub - Gradio Version
+
+This is the Gradio version of the 49ers FanAI Hub, a conversational AI application that provides information about the San Francisco 49ers football team, players, games, and fan communities.
+
+## Overview
+
+This application uses:
+- **Gradio** for the web interface
+- **LangChain** for the agent framework
+- **Neo4j** for the graph database
+- **OpenAI** for the language model
+- **Zep** for memory management
+
+## Files
+
+- `gradio_app.py` - Main application file with Gradio UI
+- `gradio_utils.py` - Utility functions for the Gradio app
+- `gradio_graph.py` - Neo4j graph connection without Streamlit dependencies
+- `gradio_llm.py` - Language model initialization without Streamlit dependencies
+- `gradio_requirements.txt` - Dependencies for the Gradio version
+
+## Setup
+
+1. Install the required dependencies:
+   ```
+   pip install -r gradio_requirements.txt
+   ```
+
+2. Set up environment variables (create a `.env` file or set them in your environment):
+   ```
+   # OpenAI API
+   OPENAI_API_KEY=your_openai_api_key
+   OPENAI_MODEL=gpt-4-turbo  # or another model
+
+   # Neo4j Database
+   NEO4J_URI=your_neo4j_uri
+   NEO4J_USERNAME=your_neo4j_username
+   NEO4J_PASSWORD=your_neo4j_password
+
+   # Zep Memory (optional)
+   ZEP_API_KEY=your_zep_api_key
+   ```
+
+3. Run the application:
+   ```
+   python gradio_app.py
+   ```
+
+4. Open your browser and navigate to the URL shown in the terminal (typically http://127.0.0.1:7860)
+
+## Features
+
+- Chat interface for asking questions about the 49ers
+- Integration with Neo4j graph database for structured data queries
+- Memory management with Zep for conversation history
+- Support for various query types:
+  - Information about players, games, and fans
+  - Finding games based on descriptions
+  - Discovering connections between people in the 49ers industry
+
+## Differences from Streamlit Version
+
+This Gradio version provides the same functionality as the Streamlit version but with a different UI framework. Key differences include:
+
+1. **State Management**: Uses a custom AppState class instead of Streamlit's session_state
+2. **UI Components**: Uses Gradio's chat interface instead of Streamlit's chat components
+3. **Error Handling**: Uses console logging instead of Streamlit's error display
+4. **Session Management**: Uses global variables for session IDs instead of Streamlit's session context
+
+## Troubleshooting
+
+- If you encounter connection issues with Neo4j, check your database credentials and network connectivity
+- If the OpenAI API is not working, verify your API key and model name
+- For Zep memory issues, ensure the Zep service is running and your API key is correct

README.md

@@ -1,3 +1,9 @@
+---
+title: ifx-sandbox
+app_file: gradio_app.py
+sdk: gradio
+sdk_version: 5.24.0
+---
 # 49ers FanAI Hub - Streamlit Version
 
 This is a Streamlit-based chatbot application that provides information about the San Francisco 49ers, players, games, and fans. The application uses LangChain, Neo4j, and Zep for memory management.

agent.py

@@ -103,7 +103,7 @@ agent_executor = AgentExecutor(
     tools=tools,
     verbose=True,
     handle_parsing_errors=True,
-    max_iterations=3  # Limit the number of iterations to prevent infinite loops
+    max_iterations=5  # Limit the number of iterations to prevent infinite loops
 )
 
 # Create a chat agent with memory

app.py

@@ -1,7 +1,4 @@
-"""
-Movie Chatbot powered by Langchain, Neo4j, Streamlit, and Zep.
-"""
-
+ 
 import os
 import uuid
 import streamlit as st

gradio_app.py

@@ -0,0 +1,228 @@
+import os
+import uuid
+import asyncio
+import gradio as gr
+from zep_cloud.client import AsyncZep
+from zep_cloud.types import Message
+
+# Import our components
+# We need to modify the agent import to use our Gradio-compatible modules
+# But we can't modify agent.py directly, so we'll import it and patch it
+import agent
+from gradio_graph import graph
+import gradio_utils
+
+# Patch the agent module to use our Gradio-compatible modules
+import sys
+import importlib
+sys.modules['graph'] = importlib.import_module('gradio_graph')
+sys.modules['llm'] = importlib.import_module('gradio_llm')
+
+# Now we can safely import generate_response
+from agent import generate_response
+
+# Initialize Zep client
+zep_api_key = os.environ.get("ZEP_API_KEY")
+if not zep_api_key:
+    print("ZEP_API_KEY environment variable is not set. Memory features will be disabled.")
+    zep = None
+else:
+    zep = AsyncZep(api_key=zep_api_key)
+
+# Global state management (replacing Streamlit's session_state)
+class AppState:
+    def __init__(self):
+        self.messages = []
+        self.initialized = False
+        self.user_id = None
+        self.session_id = None
+
+# Create a global state instance
+state = AppState()
+
+# Add welcome message to state
+welcome_message = """
+# 🏈 Welcome to the 49ers FanAI Hub! 
+        
+I can help you with:
+- Information about the 49ers, players, and fans
+- Finding 49ers games based on plot descriptions or themes
+- Discovering connections between people in the 49ers industry
+
+What would you like to know about today?
+"""
+
+# Function to initialize the chat session
+async def initialize_chat():
+    """Set up the chat session when a user connects"""
+    try:
+        # Generate unique identifiers for the user and session
+        state.user_id = gradio_utils.get_user_id()
+        state.session_id = gradio_utils.get_session_id()
+        
+        print(f"Starting new chat session. User ID: {state.user_id}, Session ID: {state.session_id}")
+        
+        # Register user in Zep if available
+        if zep:
+            await zep.user.add(
+                user_id=state.user_id,
+                email="[email protected]",
+                first_name="User",
+                last_name="MovieFan",
+            )
+            
+            # Start a new session in Zep
+            await zep.memory.add_session(
+                session_id=state.session_id,
+                user_id=state.user_id,
+            )
+        
+        
+        state.messages.append({"role": "assistant", "content": welcome_message})
+        state.initialized = True
+        
+        return welcome_message
+        
+    except Exception as e:
+        import traceback
+        print(f"Error in initialize_chat: {str(e)}")
+        print(f"Traceback: {traceback.format_exc()}")
+        error_message = "There was an error starting the chat. Please refresh the page and try again."
+        state.messages.append({"role": "system", "content": error_message})
+        return error_message
+
+# Function to process user messages
+async def process_message(message):
+    """Process user messages and generate responses with the agent"""
+    print("Starting message processing...")
+    
+    try:
+        # Store user message in Zep memory if available
+        if zep:
+            print("Storing user message in Zep...")
+            await zep.memory.add(
+                session_id=state.session_id,
+                messages=[Message(role_type="user", content=message, role="user")]
+            )
+        
+        # Add user message to state
+        state.messages.append({"role": "user", "content": message})
+        
+        # Process with the agent
+        print('Calling generate_response function...')
+        agent_response = generate_response(message, state.session_id)
+        print(f"Agent response received: {agent_response}")
+            
+        # Extract the output and metadata
+        output = agent_response.get("output", "")
+        metadata = agent_response.get("metadata", {})
+        print(f"Extracted output: {output}")
+        print(f"Extracted metadata: {metadata}")
+        
+        # Add assistant response to state
+        state.messages.append({"role": "assistant", "content": output})
+        
+        # Store assistant's response in Zep memory if available
+        if zep:
+            print("Storing assistant response in Zep...")
+            await zep.memory.add(
+                session_id=state.session_id,
+                messages=[Message(role_type="assistant", content=output, role="assistant")]
+            )
+            print("Assistant response stored in Zep")
+        
+        return output
+        
+    except Exception as e:
+        import traceback
+        print(f"Error in process_message: {str(e)}")
+        print(f"Traceback: {traceback.format_exc()}")
+        error_message = "I apologize, but I encountered an error. Could you please try again?"
+        state.messages.append({"role": "assistant", "content": error_message})
+        return error_message
+
+# Function to handle user input in Gradio
+def user_input(message, history):
+    """Handle user input and update chat history"""
+    # Return immediately to update the UI with user message
+    history.append({"role": "user", "content": message})
+    return "", history
+
+# Function to generate bot response in Gradio
+def bot_response(history):
+    """Generate bot response and update chat history"""
+    # Get the last user message
+    user_message = history[-1]["content"]
+    
+    # Process the message using asyncio.run
+    response = asyncio.run(process_message(user_message))
+    
+    # Add the assistant's response to history
+    history.append({"role": "assistant", "content": response})
+    
+    return history
+
+# Function to initialize the chat when the app starts
+#async def on_app_start():
+    """Initialize the chat when the app starts"""
+    #if not state.initialized:
+    #    welcome_message = await initialize_chat()
+    #    return [{"role": "assistant", "content": welcome_message}]
+    #return []
+
+# Initialize the chat before creating the interface
+#initial_messages = asyncio.run(on_app_start())
+initial_messages = [{"role": "assistant", "content": welcome_message}]
+
+# Create the Gradio interface
+with gr.Blocks(title="49ers FanAI Hub", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🏈 49ers FanAI Hub")
+    
+    # Chat interface
+    chatbot = gr.Chatbot(
+        value=initial_messages,
+        height=500,
+        show_label=False,
+        elem_id="chatbot",
+        type="messages"  # Use the new messages format
+    )
+    
+    # Input components
+    with gr.Row():
+        msg = gr.Textbox(
+            placeholder="Ask me about the 49ers...",
+            show_label=False,
+            scale=9
+        )
+        submit = gr.Button("Send", scale=1)
+    
+    # Define a combined function for user input and bot response
+    async def process_and_respond(message, history):
+        # If not initialized yet, do it now
+        if not state.initialized:
+            welcome_message = await initialize_chat()
+            # Optionally show the welcome message right away
+            history.append({"role": "assistant", "content": welcome_message})
+
+        # Now handle the actual user message
+        history.append({"role": "user", "content": message})
+        response = await process_message(message)
+        history.append({"role": "assistant", "content": response})
+
+        return "", history
+
+
+    
+    # Set up event handlers with the combined function - explicitly disable queue
+    msg.submit(process_and_respond, [msg, chatbot], [msg, chatbot], queue=False)
+    submit.click(process_and_respond, [msg, chatbot], [msg, chatbot], queue=False)
+    
+    # Add a clear button
+    clear = gr.Button("Clear Conversation")
+    clear.click(lambda: [], None, chatbot, queue=False)
+
+# Launch the app
+if __name__ == "__main__":
+    # Disable the queue completely
+    #demo.queue(enabled=False)
+    demo.launch(share=True) 

gradio_graph.py

@@ -0,0 +1,62 @@
+"""
+This module initializes the Neo4j graph connection without Streamlit dependencies.
+"""
+
+import os
+from dotenv import load_dotenv
+from langchain_neo4j import Neo4jGraph
+
+# Load environment variables
+load_dotenv()
+
+# Get Neo4j credentials from environment
+def get_credential(key_name):
+    """Get credential from environment variables"""
+    # Try different possible environment variable names
+    possible_names = [key_name]
+    
+    # Add alternative names
+    if key_name.startswith("AURA_"):
+        possible_names.append(f"NEO4J_{key_name[5:]}")
+    elif key_name.startswith("NEO4J_"):
+        possible_names.append(f"AURA_{key_name[6:]}")
+    
+    # Try each possible name
+    for name in possible_names:
+        value = os.environ.get(name)
+        if value:
+            return value
+    
+    return None
+
+# Get Neo4j credentials
+AURA_CONNECTION_URI = get_credential("AURA_CONNECTION_URI") or get_credential("NEO4J_URI")
+AURA_USERNAME = get_credential("AURA_USERNAME") or get_credential("NEO4J_USERNAME")
+AURA_PASSWORD = get_credential("AURA_PASSWORD") or get_credential("NEO4J_PASSWORD")
+
+# Check if credentials are available
+if not all([AURA_CONNECTION_URI, AURA_USERNAME, AURA_PASSWORD]):
+    missing = []
+    if not AURA_CONNECTION_URI:
+        missing.append("AURA_CONNECTION_URI/NEO4J_URI")
+    if not AURA_USERNAME:
+        missing.append("AURA_USERNAME/NEO4J_USERNAME")
+    if not AURA_PASSWORD:
+        missing.append("AURA_PASSWORD/NEO4J_PASSWORD")
+    
+    error_message = f"Missing Neo4j credentials: {', '.join(missing)}"
+    print(f"ERROR: {error_message}")
+    raise ValueError(error_message)
+
+# Connect to Neo4j
+try:
+    graph = Neo4jGraph(
+        url=AURA_CONNECTION_URI,
+        username=AURA_USERNAME,
+        password=AURA_PASSWORD,
+    )
+    print("Successfully connected to Neo4j database")
+except Exception as e:
+    error_message = f"Failed to connect to Neo4j: {str(e)}"
+    print(f"ERROR: {error_message}")
+    raise Exception(error_message)

gradio_llm.py

@@ -0,0 +1,43 @@
+"""
+This module initializes the language model and embedding model without Streamlit dependencies.
+"""
+
+import os
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+
+# Load environment variables
+load_dotenv()
+
+# Get API keys from environment
+def get_api_key(key_name):
+    """Get API key from environment variables"""
+    return os.environ.get(key_name)
+
+OPENAI_API_KEY = get_api_key("OPENAI_API_KEY")
+OPENAI_MODEL = get_api_key("OPENAI_MODEL") or "gpt-4-turbo"
+
+if not OPENAI_API_KEY:
+    error_message = "OPENAI_API_KEY is not set in environment variables."
+    print(f"ERROR: {error_message}")
+    raise ValueError(error_message)
+
+# Create the LLM with better error handling
+try:
+    llm = ChatOpenAI(
+        openai_api_key=OPENAI_API_KEY,
+        model=OPENAI_MODEL,
+        temperature=0.1,
+        streaming=True  # Enable streaming for better response handling
+    )
+
+    # Create the Embedding model
+    embeddings = OpenAIEmbeddings(
+        openai_api_key=OPENAI_API_KEY
+    )
+    
+    print(f"Successfully initialized OpenAI models (using {OPENAI_MODEL})")
+except Exception as e:
+    error_message = f"Failed to initialize OpenAI models: {str(e)}"
+    print(f"ERROR: {error_message}")
+    raise Exception(error_message)

gradio_requirements.txt

@@ -0,0 +1,12 @@
+gradio>=4.0.0
+langchain>=0.1.0
+langchain-openai>=0.0.5
+langchain-core>=0.1.15
+langchain-neo4j>=0.1.1
+openai>=1.2.0
+neo4j>=5.14.0
+python-dotenv>=1.0.0
+uuid>=1.30
+zep-cloud>=0.1.0
+asyncio>=3.4.3
+pandas>=2.0.0

gradio_utils.py

@@ -0,0 +1,53 @@
+"""
+Utility functions for the Gradio-based chatbot application.
+"""
+
+import uuid
+
+# Global state for session and user IDs
+_session_id = None
+_user_id = None
+
+def get_session_id():
+    """
+    Get the current session ID.
+    Creates a new ID if one doesn't exist.
+    """
+    global _session_id
+    if _session_id is None:
+        _session_id = str(uuid.uuid4())
+    return _session_id
+
+def get_user_id():
+    """
+    Get the current user ID.
+    Creates a new ID if one doesn't exist.
+    """
+    global _user_id
+    if _user_id is None:
+        _user_id = str(uuid.uuid4())
+    return _user_id
+
+def reset_ids():
+    """
+    Reset both session and user IDs.
+    Useful for testing or when starting a new session.
+    """
+    global _session_id, _user_id
+    _session_id = None
+    _user_id = None
+
+def format_source_documents(source_documents):
+    """
+    Format source documents for display.
+    """
+    if not source_documents:
+        return None
+        
+    formatted_docs = []
+    for i, doc in enumerate(source_documents):
+        if hasattr(doc, 'metadata') and doc.metadata:
+            source = doc.metadata.get('source', 'Unknown')
+            formatted_docs.append(f"Source {i+1}: {source}")
+    
+    return "\n".join(formatted_docs) if formatted_docs else None