updated with react framework

app.py

@@ -8,13 +8,12 @@ import re
 
 # Configure logging
 logging.basicConfig(
-    filename='app.log',
+    filename="app.log",
     level=logging.DEBUG,
-    format='%(asctime)s - %(levelname)s - %(message)s'
+    format="%(asctime)s - %(levelname)s - %(message)s",
 )
 
-# Test logging
-logging.debug("Logging is configured correctly and this is a test message.")
+logging.debug("Logging is configured correctly.")
 
 # Load environment variables
 load_dotenv()
@@ -27,79 +26,69 @@ if not GROQ_API_KEY:
 
 client = Groq(api_key=GROQ_API_KEY)
 
-# Define the Reflexion system prompt template
-SYSTEM_PROMPT_TEMPLATE = (
-    "You are an advanced AI agent leveraging the Reflexion framework to iteratively improve ideas and responses through up to {reflection_cycles} cycles of reflection. "
-    "Your goal is to provide the most meaningful, relevant, and impactful results while autonomously managing the process. Follow the structured workflow below:\n\n"
-    "CRITICAL: Your entire response MUST be a valid JSON object. Follow these strict formatting rules:\n"
-    "1. Use double quotes (\") for all JSON keys and string values\n"
-    "2. Escape any double quotes within string values with a backslash (\\\")\n"
-    "3. Avoid using any unescaped special characters or line breaks within string values\n"
-    "4. Ensure all JSON keys and values are properly enclosed and comma-separated\n\n"
-    "Required JSON Structure:\n"
-    "{{\n"
-    "  \"initial_response\": \"<Provide the initial response here as a string>\",\n"
-    "  \"reflection_cycles\": [\n"
-    "    {{\n"
-    "      \"cycle\": <Cycle number>,\n"
-    "      \"alignment\": \"<Reflection on alignment>\",\n"
-    "      \"feasibility\": \"<Reflection on feasibility>\",\n"
-    "      \"depth\": \"<Reflection on depth>\",\n"
-    "      \"impact\": \"<Reflection on impact>\",\n"
-    "      \"refined_response\": \"<Refined response after this reflection cycle>\"\n"
-    "    }}\n"
-    "  ],\n"
-    "  \"final_output\": \"<Final, polished response>\"\n"
-    "}}\n\n"
-    "Initial Response:\n"
-    "Begin with the following input and provide a well-considered, thoughtful initial answer:\n\n"
-    "{user_input}\n\n"
-    "Reflection Cycles (Up to {reflection_cycles}):\n"
-    "After each response, perform a critical reflection, considering the following:\n"
-    "- Alignment: Does the answer align with the user's intent?\n"
-    "- Feasibility: Are the ideas or solutions practical and actionable?\n"
-    "- Depth: Are there gaps, ambiguities, or missed perspectives?\n"
-    "- Impact: How meaningful and beneficial is the response to the user?\n"
-    "Use the feedback from this reflection to refine the response and document it in the JSON structure.\n\n"
-    "Final Output:\n"
-    "Provide a final, polished response as the \"final_output\" field in the JSON. The response should be thoughtful, comprehensive, and fully address the user's query.\n\n"
-    "Previous Context:\n{history_context}\n\n"
-    "REMINDER: Verify that your response is valid JSON before completing. Do not include any text outside of the JSON structure."
-)
+# Define the ReAct system prompt template
+SYSTEM_PROMPT_TEMPLATE = """
+You are an advanced AI agent using the ReAct (Reasoning + Action) framework to solve complex tasks. Follow these steps iteratively:
+1. Generate a "Thought" based on the current input or observations.
+2. Decide on an "Action" (e.g., search, calculation, etc.) to take.
+3. Return an "Observation" after the action to guide the next step.
+Continue this loop until the task is solved or no further actions are needed. Return the result in this JSON format:
+
+{{
+  "thoughts": [
+    {{
+      "thought": "<Reasoning step>",
+      "action": "<Action taken>",
+      "observation": "<Result of the action>"
+    }}
+  ],
+  "final_result": "<Final answer or solution>"
+}}
+
+Previous Context:
+{history_context}
+
+Input:
+{user_input}
+"""
+
 
 # Initialize Streamlit app
-st.title("Reflexion AI Chatbot")
+st.title("ReAct AI Chatbot")
 
 # Initialize session state
 if "messages" not in st.session_state:
     st.session_state.messages = []
-if "refined_history" not in st.session_state:
-    st.session_state.refined_history = []
+if "react_history" not in st.session_state:
+    st.session_state.react_history = []
+
 
 def sanitize_json(json_str):
-    json_str = re.sub(r'[\x00-\x1F\x7F]', '', json_str)  # Remove control characters
+    json_str = re.sub(r"[\x00-\x1F\x7F]", "", json_str)  # Remove control characters
     return json_str
 
-# Function to generate responses using the Groq API
-def generate_response(user_input, refined_history):
+def generate_react_response(user_input, react_history):
+    """
+    Generate a ReAct-based response for the given input.
+    """
     try:
-        # Filter out None values and ensure all items are strings
-        valid_history = [str(item) for item in refined_history if item is not None]
-        
-        # Limit the number of historical responses
+        # Combine history context
         MAX_HISTORY = 5
-        history_context = " ".join(valid_history[-MAX_HISTORY:])
+        history_context = "\n".join(react_history[-MAX_HISTORY:])
+        logging.debug(f"History Context: {history_context}")
 
-        # Format the system prompt with history and current input
-        formatted_prompt = SYSTEM_PROMPT_TEMPLATE.format(
-            reflection_cycles=reflection_cycles,
-            user_input=user_input,
-            history_context=history_context
-        )
+        # Ensure the user_input is sanitized
+        user_input = sanitize_json(user_input)
+        logging.debug(f"Sanitized User Input: {user_input}")
 
-        logging.debug(f"Formatted Prompt Sent: {formatted_prompt}")
+        # Format the system prompt
+        formatted_prompt = SYSTEM_PROMPT_TEMPLATE.format_map({
+            "user_input": user_input,
+            "history_context": history_context or "No context available."
+        })
+        logging.debug(f"Formatted Prompt: {formatted_prompt}")
 
-        # Send API request
+        # Send the request to the Groq API
         chat_completion = client.chat.completions.create(
             model="llama3-8b-8192",
             messages=[
@@ -111,69 +100,95 @@ def generate_response(user_input, refined_history):
             top_p=0.9,
         )
 
-        logging.debug(f"Full API Response: {chat_completion}")
-
-        # Ensure choices exist
-        if not chat_completion.choices or len(chat_completion.choices) == 0:
-            raise ValueError("No valid choices found in response.")
+        logging.debug(f"Raw API Response: {chat_completion}")
 
+        # Extract content from the response
         content = chat_completion.choices[0].message.content
         if not content:
             logging.warning("Received empty content in API response.")
             return None
 
-        # Parse JSON response
-        content = content.strip()
-        if not content.startswith('{'):
-            start_idx = content.find('{')
-            if start_idx != -1:
-                content = content[start_idx:]
-        if not content.endswith('}'):
-            end_idx = content.rfind('}')
-            if end_idx != -1:
-                content = content[:end_idx + 1]
-
-        # Sanitize JSON before parsing
-        cleaned_json = sanitize_json(content)
-        parsed_json = json.loads(cleaned_json)
-        logging.debug(f"Parsed JSON Response: {parsed_json}")
-        return parsed_json
+        # Updated regex patterns to capture full content including recipe details
+        thought_match = re.search(r'\*\*Thought:?\*\*:?\s*"?(.*?)(?="?\s*\*\*Action|\n\n|$)', content, re.DOTALL | re.IGNORECASE)
+        action_match = re.search(r'\*\*Action:?\*\*:?\s*"?(.*?)(?="?\s*\*\*Observation|\n\n|$)', content, re.DOTALL | re.IGNORECASE)
+        observation_match = re.search(r'\*\*Observation:?\*\*:?\s*"?(.*?)(?=\n\n\*\*Thought|\Z)', content, re.DOTALL | re.IGNORECASE)
+
+        # Extract and clean the matches
+        thought = thought_match.group(1).strip(' "') if thought_match else "No thought provided"
+        action = action_match.group(1).strip(' "') if action_match else "No action provided"
+        observation = observation_match.group(1).strip(' "') if observation_match else "No observation provided"
+
+        # Check if observation contains a recipe (indicated by "Ingredients:" or "Instructions:")
+        if "Ingredients:" in observation or "Instructions:" in observation:
+            final_result = observation  # Use the full recipe text as the final result
+        else:
+            final_result = observation if observation != "No observation provided" else "Ready to provide assistance once preferences are specified."
+
+        parsed_response = {
+            "thoughts": [{
+                "thought": thought,
+                "action": action,
+                "observation": observation
+            }],
+            "final_result": final_result
+        }
+
+        logging.debug(f"Parsed Response: {parsed_response}")
+        return parsed_response
 
     except Exception as e:
-        logging.error(f"Error generating response: {e}", exc_info=True)
+        logging.error(f"Error generating ReAct response: {e}", exc_info=True)
         return {
-            "initial_response": "Error occurred",
-            "reflection_cycles": [],
-            "final_output": f"An error occurred: {str(e)}",
+            "thoughts": [],
+            "final_result": f"An error occurred: {str(e)}",
         }
 
-# Display chat messages from history on app rerun
+
+
+# Display chat messages from history
 for message in st.session_state.messages:
     with st.chat_message(message["role"]):
         st.markdown(message["content"])
 
 # Accept user input
-user_input = st.chat_input("You: ")
+user_input = st.chat_input("Enter your query:")
 
-# Check if user input is submitted via Enter
 if user_input:
-    # Display user message in chat message container
+    # Display user message
     st.chat_message("user").markdown(user_input)
     st.session_state.messages.append({"role": "user", "content": user_input})
 
-    # Generate and display assistant response
-    with st.spinner("Generating response..."):
-        response = generate_response(user_input, st.session_state.refined_history)
+    # Generate ReAct-based response
+    with st.spinner("Thinking..."):
+        response = generate_react_response(user_input, st.session_state.react_history)
+
         if response:
             try:
-                refined_response = response.get("final_output", "")
-                if refined_response:  # Only append non-empty responses
-                    # Add the refined response to history
-                    st.session_state.refined_history.append(refined_response)
-                    
-                    # Display the refined response
-                    st.chat_message("assistant").markdown(refined_response)
-                    st.session_state.messages.append({"role": "assistant", "content": refined_response})
+                # Process thoughts and actions
+                thoughts = response.get("thoughts", [])
+                for step in thoughts:
+                    thought = step.get("thought", "No thought provided.")
+                    action = step.get("action", "No action taken.")
+                    observation = step.get("observation", "No observation.")
+
+                    st.chat_message("assistant").markdown(
+                        f"**Thought:** {thought}\n\n**Action:** {action}\n\n**Observation:** {observation}"
+                    )
+                    st.session_state.messages.append(
+                        {
+                            "role": "assistant",
+                            "content": f"**Thought:** {thought}\n\n**Action:** {action}\n\n**Observation:** {observation}",
+                        }
+                    )
+
+                # Final result
+                final_result = response.get("final_result", "No final result.")
+                st.chat_message("assistant").markdown(f"**Final Result:** {final_result}")
+                st.session_state.messages.append({"role": "assistant", "content": f"**Final Result:** {final_result}"})
+
+                # Update history
+                st.session_state.react_history.append(f"User: {user_input}\nAI: {final_result}")
+
             except Exception as e:
-                logging.error(f"Error parsing response: {e}")
-                st.error("Failed to process the response.")
+                logging.error(f"Error processing ReAct response: {e}")
+                st.error("Failed to process the ReAct response.")