Update app.py

app.py

@@ -3,25 +3,31 @@ from flask import Flask, request, jsonify, render_template
 import requests
 import json
 import asyncio
-import os # Import os to access environment variables
+import os
+import uuid # For generating unique session IDs if not provided
 
 app = Flask(__name__)
 
-# --- Your AI Tool Logic (Modified for Hugging Face) ---
-async def generate_solution_python(user_query):
+# In-memory storage for conversation histories
+# This will reset if the Flask application restarts.
+# For persistent history, a database (like Firestore) is required.
+conversation_histories = {}
+
+async def generate_solution_python(chat_history):
     """
     Generates a solution using a dummy context (since google_search is not available)
-    and Gemini LLM.
+    and Gemini LLM, based on the provided chat history.
 
     Args:
-        user_query (str): The query provided by the user.
+        chat_history (list): A list of message objects representing the conversation.
+                             Each object has "role" and "parts" (e.g., [{"text": "..."}]).
     Returns:
         str: The generated solution text or an error message.
     """
-    if not user_query:
-        return "Error: Query is required."
+    if not chat_history:
+        return "Error: Chat history is empty."
 
-    print(f"Processing query: {user_query}")
+    print(f"Processing chat history length: {len(chat_history)}")
     response_text = ""
 
     try:
@@ -29,39 +35,25 @@ async def generate_solution_python(user_query):
         # The 'google_search' tool is specific to the Canvas environment.
         # On Hugging Face, you would integrate a real public search API here,
         # e.g., Google Custom Search API, SerpAPI, or a web scraping library.
-        # For this example, we'll use a dummy context.
-        dummy_context = f"Information related to '{user_query}' from various online sources indicates that..."
-        
-        # In a real scenario, you'd make an API call like this (example with a hypothetical search API):
-        # search_api_key = os.environ.get("YOUR_SEARCH_API_KEY")
-        # if not search_api_key:
-        #     raise ValueError("YOUR_SEARCH_API_KEY environment variable not set.")
-        # search_api_url = "https://api.example.com/search"
-        # search_response = requests.get(search_api_url, params={"q": user_query, "api_key": search_api_key})
-        # search_response.raise_for_status()
-        # search_results = search_response.json()
-        # context = process_search_results(search_results) # A function to extract snippets
-
-        context = dummy_context # Using dummy context for now
-
-        # Step 2: Construct prompt for LLM with context
-        chat_history = []
-        prompt = f"""You are an AI assistant that provides comprehensive solutions based on the given query and additional context from open sources.
+        # For this example, we'll use a dummy context based on the latest user query.
 
-User Query: {user_query}
+        # Find the latest user query to generate a relevant dummy context
+        latest_user_query = ""
+        for message in reversed(chat_history):
+            if message["role"] == "user" and message["parts"] and message["parts"][0].get("text"):
+                latest_user_query = message["parts"][0]["text"]
+                break
 
-Relevant Open-Source Information:
-{context}
-
-Please provide a detailed and helpful solution, incorporating the provided information where relevant. If the information is insufficient, state that and provide a general answer.
-"""
-
-        chat_history.append({"role": "user", "parts": [{"text": prompt}]})
+        dummy_context = f"Information related to '{latest_user_query}' from various online sources indicates that..."
+        
+        # You could also inject this context into the chat_history as a system message
+        # or prepend it to the latest user message's text if you want the LLM to explicitly
+        # see it as part of the conversation flow. For now, it's implicitly part of the prompt.
 
-        # Step 3: Call Gemini API
-        print("Calling Gemini API...")
+        # Step 2: Call Gemini API with the full chat history
+        print("Calling Gemini API with full chat history...")
         llm_payload = {
-            "contents": chat_history
+            "contents": chat_history # Pass the entire history
         }
 
         # Get API key from environment variables (Hugging Face Space Secrets)
@@ -112,26 +104,42 @@ def index():
 
 @app.route('/generate', methods=['POST'])
 async def generate():
-    """Handles the AI generation request."""
+    """Handles the AI generation request, managing conversation history."""
     try:
-        # Try to parse JSON from the request body
         data = request.get_json()
         if not data:
             return jsonify({"error": "Request body must be JSON"}), 400
 
         user_query = data.get('query')
+        session_id = data.get('session_id')
+
         if not user_query:
             return jsonify({"error": "Query is required in the request body"}), 400
+        if not session_id:
+            # Generate a session ID if not provided (should be provided by frontend)
+            session_id = str(uuid.uuid4())
+            print(f"Warning: session_id not provided, generated new one: {session_id}")
+
+        # Retrieve or initialize chat history for this session
+        current_chat_history = conversation_histories.get(session_id, [])
+
+        # Append the new user message to the history
+        current_chat_history.append({"role": "user", "parts": [{"text": user_query}]})
+
+        # Generate the solution using the full chat history
+        solution_text = await generate_solution_python(current_chat_history)
+
+        # Append the model's response to the history
+        current_chat_history.append({"role": "model", "parts": [{"text": solution_text}]})
+        
+        # Store the updated history
+        conversation_histories[session_id] = current_chat_history
 
-        # Run the async function
-        solution = await generate_solution_python(user_query)
-        return jsonify({"solution": solution})
+        return jsonify({"solution": solution_text, "session_id": session_id})
 
     except Exception as e:
-        # Catch any unexpected errors during request processing or function call
         print(f"Error in /generate endpoint: {e}")
         return jsonify({"error": f"Internal server error: {e}"}), 500
 
 if __name__ == '__main__':
-    # Hugging Face Spaces typically expect the app to run on port 7860
     app.run(host='0.0.0.0', port=7860)