update app

app.py

@@ -1,37 +1,35 @@
 import os
-import streamlit as st
+import gradio as gr
 from neo4j import GraphDatabase
 from langchain_community.graphs import Neo4jGraph
 from dotenv import load_dotenv
 
-# Load environment variables from .env file for local development
+# 1. Load environment variables
 load_dotenv()
 
+# Helper function to get env vars with a fallback error
+def get_env_var(key):
+    value = os.getenv(key)
+    if not value:
+        raise ValueError(f"Environment variable '{key}' is missing. Please set it in your .env file.")
+    return value
+
+NEO4J_URI = get_env_var("NEO4J_URI")
+NEO4J_USER = get_env_var("NEO4J_USER")
+NEO4J_PASSWORD = get_env_var("NEO4J_PASSWORD")
+
+# 2. Define the Native Connection Class
 class Neo4jConnection:
     """
-    A class to manage the connection to a Neo4j database.
-    It uses the credentials sourced from Streamlit secrets or a local .env file.
+    A class to manage the connection to a Neo4j database using the native driver.
     """
-    def __init__(self):
-        # Prioritize Streamlit secrets, fall back to .env for local dev
-        if hasattr(st, 'secrets') and "NEO4J_URI" in st.secrets:
-            uri = st.secrets["NEO4J_URI"]
-            user = st.secrets["NEO4J_USER"]
-            password = st.secrets["NEO4J_PASSWORD"]
-            print("Connecting to Neo4j using Streamlit secrets.")
-        else:
-            uri = os.getenv("NEO4J_URI")
-            user = os.getenv("NEO4J_USER")
-            password = os.getenv("NEO4J_PASSWORD")
-            print("Connecting to Neo4j using local .env file.")
-
+    def __init__(self, uri, user, password):
         self._driver = GraphDatabase.driver(uri, auth=(user, password))
         try:
-            # Verify connection
             self._driver.verify_connectivity()
-            print("Connected to Neo4j")
+            print("Native Neo4j Driver: Connected successfully.")
         except Exception as e:
-            print(f"Neo4j connection failed: {e}")
+            print(f"Native Neo4j Driver connection failed: {e}")
 
     def close(self):
         if self._driver is not None:
@@ -45,23 +43,78 @@ class Neo4jConnection:
         try:
             session = self._driver.session(database=db) if db is not None else self._driver.session()
             response = list(session.run(query, parameters))
+            # Convert Neo4j records to simple dicts for easy reading in UI
+            response = [r.data() for r in response] 
         except Exception as e:
-            print("Query failed:", e)
+            return f"Query failed: {e}"
         finally:
             if session is not None:
                 session.close()
         return response
 
+# 3. Initialize Connections (Global State)
 
-graph = Neo4jGraph(
-    url=st.secrets["NEO4J_URI"], 
-    username=st.secrets["NEO4J_USER"], 
-    password=st.secrets["NEO4J_PASSWORD"]
-)
+# Initialize Native Driver
+conn = Neo4jConnection(NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD)
 
-# Refresh schema information for the LangChain graph object
-# This helps the LLM generate more accurate Cypher queries
+# Initialize LangChain Graph
+# Note: In a persistent web server (like Gradio), we usually init this once globally.
+print("Initializing LangChain Graph...")
 try:
+    graph = Neo4jGraph(
+        url=NEO4J_URI, 
+        username=NEO4J_USER, 
+        password=NEO4J_PASSWORD
+    )
     graph.refresh_schema()
+    print("LangChain Graph Schema refreshed.")
 except Exception as e:
-    print(f"Warning: Could not refresh graph schema. The LLM might generate less accurate queries. Error: {e}")
+    print(f"Warning: Could not refresh graph schema. Error: {e}")
+
+
+# 4. Define Application Logic
+def run_cypher(query_text):
+    """
+    Function triggered by the Gradio UI.
+    """
+    if not query_text:
+        return "Please enter a query."
+    
+    results = conn.query(query_text)
+    return results
+
+def get_schema_info():
+    """
+    Returns the LangChain graph schema to display in the UI.
+    """
+    try:
+        return graph.get_schema
+    except Exception as e:
+        return str(e)
+
+# 5. Build Gradio Interface
+with gr.Blocks(title="Neo4j Graph Explorer") as demo:
+    gr.Markdown("# Neo4j Connection Demo")
+    
+    with gr.Tab("Execute Cypher"):
+        gr.Markdown("Enter a Cypher query to test your connection.")
+        cypher_input = gr.Code(language="cypher", label="Cypher Query", value="MATCH (n) RETURN n LIMIT 5")
+        run_btn = gr.Button("Run Query", variant="primary")
+        json_output = gr.JSON(label="Query Results")
+        
+        run_btn.click(fn=run_cypher, inputs=cypher_input, outputs=json_output)
+
+    with gr.Tab("Graph Schema"):
+        gr.Markdown("View the current schema detected by LangChain.")
+        refresh_btn = gr.Button("View Schema")
+        schema_output = gr.Textbox(label="Schema Definition", lines=10)
+        
+        refresh_btn.click(fn=get_schema_info, inputs=None, outputs=schema_output)
+
+# 6. Launch
+if __name__ == "__main__":
+    # Ensure the connection closes when the app stops (optional cleanup)
+    try:
+        demo.launch()
+    finally:
+        conn.close()