Update app.py

app.py

@@ -23,10 +23,20 @@ CHATS = {"Main Chat": []}
 CURRENT_CHAT = "Main Chat"
 
 # System prompt and generation config
-SYSTEM_PROMPT = "You are a helpful AI assistant based on the Mistral-7B-Instruct model. You specialize in creating structured JSON data for automation workflows like n8n. When asked, format JSON properly with correct indentation and structure."
+SYSTEM_PROMPT = """You are a helpful AI assistant based on the Mistral-7B-Instruct model. 
+You specialize in creating structured JSON data for automation workflows like n8n.
+When asked to create JSON for n8n workflows:
+1. Structure the data in valid JSON format with proper nesting
+2. Include all necessary fields and properties for nodes
+3. Format with correct indentation and structure
+4. Use proper n8n node syntax and follow their data structure requirements
+5. Always validate the JSON before returning it
+
+For JSON workflow nodes, be attentive to detail and include all necessary fields."""
+
 GENERATE_CONFIG = {
-    "max_new_tokens": 512,
-    "temperature": 0.7,
+    "max_new_tokens": 1024,  # Increased for complex JSON responses
+    "temperature": 0.5,      # Slightly lower for more precise JSON
     "top_p": 0.95,
     "top_k": 50,
     "repetition_penalty": 1.1,
@@ -77,7 +87,10 @@ def generate_response(prompt, chat_history, progress=gr.Progress()):
     global MODEL, TOKENIZER, PIPE, CHATS, CURRENT_CHAT, SYSTEM_PROMPT, GENERATE_CONFIG, FILE_DATA, ANALYZED_DATA
     
     if not MODEL_LOADED:
-        return "Model is still loading. Please wait a moment before sending messages."
+        if MODEL_LOADING:
+            return chat_history + [("Your message", "Model is still loading. Please wait a moment before sending messages.")]
+        else:
+            return chat_history + [("Your message", "Model not loaded. Please click 'Load Mistral-7B Model' first.")]
     
     try:
         # Use the current chat's history
@@ -95,6 +108,10 @@ def generate_response(prompt, chat_history, progress=gr.Progress()):
             if msg["role"] != "system":  # Skip system messages in the history
                 conversation.append({"role": msg["role"], "content": msg["content"]})
         
+        # Check if JSON formatting is specifically requested
+        is_json_request = any(keyword in prompt.lower() 
+                            for keyword in ["json", "n8n", "workflow", "automation", "format"])
+        
         # Handle file-related queries by including context
         if ANALYZED_DATA is not None and any(keyword in prompt.lower() 
                                              for keyword in ["file", "data", "analyze", "show", "tell me about", "json"]):
@@ -125,6 +142,10 @@ def generate_response(prompt, chat_history, progress=gr.Progress()):
             enhanced_prompt = f"{prompt}\n\nContext about the file: {file_context}"
         else:
             enhanced_prompt = prompt
+        
+        # If this is a JSON request, add special instructions
+        if is_json_request:
+            enhanced_prompt += "\n\nPlease generate a valid, properly formatted JSON response suitable for n8n workflows. Include all necessary fields and ensure correct formatting. The JSON should be valid and ready to be imported directly into n8n."
             
         # Add current prompt
         conversation.append({"role": "user", "content": enhanced_prompt})
@@ -167,15 +188,31 @@ def generate_response(prompt, chat_history, progress=gr.Progress()):
             "content": generated_text
         })
         
-        # Update the chat history for the Gradio component
+        # Validate and format JSON if it appears to be a JSON response
+        if is_json_request and "```json" in generated_text:
+            try:
+                # Try to extract JSON from code blocks
+                json_match = re.search(r'```json\s*([\s\S]*?)\s*```', generated_text)
+                if json_match:
+                    json_string = json_match.group(1)
+                    # Parse and re-stringify to ensure proper formatting
+                    parsed_json = json.loads(json_string)
+                    formatted_json = json.dumps(parsed_json, indent=2)
+                    
+                    # Replace the original JSON with the properly formatted one
+                    generated_text = generated_text.replace(json_match.group(0), f"```json\n{formatted_json}\n```")
+            except json.JSONDecodeError:
+                # If JSON parsing fails, we keep the original response
+                pass
+        
+        # Update the chat history for the Gradio component (fix the tuple format)
         chat_history.append((prompt, generated_text))
         
         return chat_history
     
     except Exception as e:
         error_message = f"Error generating response: {str(e)}"
-        chat_history.append((prompt, error_message))
-        return chat_history
+        return chat_history + [(prompt, error_message)]
 
 # Function to create a new chat
 def create_new_chat(chat_name):
@@ -284,6 +321,118 @@ def analyze_uploaded_file(file):
     except Exception as e:
         return f"Error analyzing file: {str(e)}"
 
+# Function to convert data to n8n JSON format
+def convert_to_n8n_json():
+    global ANALYZED_DATA
+    
+    if ANALYZED_DATA is None:
+        return "No file has been analyzed yet. Please upload a file first."
+    
+    try:
+        if ANALYZED_DATA['type'] in ['csv', 'excel']:
+            # Convert DataFrame to n8n compatible JSON
+            data = ANALYZED_DATA['data']
+            records = data.to_dict(orient='records')
+            
+            # Generate n8n workflow JSON template
+            n8n_json = {
+                "name": "Generated Data Workflow",
+                "nodes": [
+                    {
+                        "parameters": {
+                            "jsCode": f"return {json.dumps(records, indent=2)};"
+                        },
+                        "id": "1",
+                        "name": "Code",
+                        "type": "n8n-nodes-base.code",
+                        "typeVersion": 1,
+                        "position": [
+                            250,
+                            300
+                        ]
+                    }
+                ],
+                "connections": {},
+                "active": False,
+                "settings": {},
+                "version": 1,
+                "meta": {
+                    "instanceId": "GENERATED"
+                }
+            }
+            
+            return json.dumps(n8n_json, indent=2)
+        
+        elif ANALYZED_DATA['type'] == 'json':
+            # The data is already in JSON format, just need to wrap it in n8n structure
+            data = ANALYZED_DATA['data']
+            
+            n8n_json = {
+                "name": "JSON Workflow",
+                "nodes": [
+                    {
+                        "parameters": {
+                            "jsCode": f"return {json.dumps(data, indent=2)};"
+                        },
+                        "id": "1",
+                        "name": "Code",
+                        "type": "n8n-nodes-base.code",
+                        "typeVersion": 1,
+                        "position": [
+                            250,
+                            300
+                        ]
+                    }
+                ],
+                "connections": {},
+                "active": False,
+                "settings": {},
+                "version": 1,
+                "meta": {
+                    "instanceId": "GENERATED"
+                }
+            }
+            
+            return json.dumps(n8n_json, indent=2)
+        
+        elif ANALYZED_DATA['type'] == 'text':
+            # Convert text to a simple n8n workflow
+            text_data = ANALYZED_DATA['data']
+            
+            n8n_json = {
+                "name": "Text Processing Workflow",
+                "nodes": [
+                    {
+                        "parameters": {
+                            "jsCode": f"return {{ text: {json.dumps(text_data)} }};"
+                        },
+                        "id": "1",
+                        "name": "Code",
+                        "type": "n8n-nodes-base.code",
+                        "typeVersion": 1,
+                        "position": [
+                            250,
+                            300
+                        ]
+                    }
+                ],
+                "connections": {},
+                "active": False,
+                "settings": {},
+                "version": 1,
+                "meta": {
+                    "instanceId": "GENERATED"
+                }
+            }
+            
+            return json.dumps(n8n_json, indent=2)
+        
+        else:
+            return "Cannot convert this file type to n8n JSON format."
+    
+    except Exception as e:
+        return f"Error generating n8n JSON: {str(e)}"
+
 # Function to update system prompt
 def update_system_prompt(new_prompt):
     global SYSTEM_PROMPT
@@ -374,15 +523,17 @@ def create_gradio_interface():
     .chat-message-user {background-color: #e0f7fa; padding: 12px; border-radius: 8px; margin-bottom: 8px}
     .chat-message-bot {background-color: #f1f8e9; padding: 12px; border-radius: 8px; margin-bottom: 8px}
     .file-info {border: 1px solid #ddd; padding: 15px; border-radius: 5px; margin-top: 10px}
+    .json-output {font-family: monospace; white-space: pre; overflow-x: auto; background-color: #f5f5f5; padding: 15px; border-radius: 5px;}
     """
     
     # Setup tabs for different functionalities
     with gr.Blocks(css=css) as app:
-        gr.Markdown("# 🤖 Advanced Mistral-7B-Instruct Chatbot")
+        gr.Markdown("# 🤖 Advanced Mistral-7B-Instruct Chatbot for n8n JSON Generation")
         
         with gr.Tab("Chat"):
             with gr.Row():
                 with gr.Column(scale=3):
+                    # Initialize with empty list to fix the tuple format error
                     chatbot = gr.Chatbot(
                         [],
                         elem_id="chatbot",
@@ -464,27 +615,86 @@ def create_gradio_interface():
                     )
                     update_params_btn = gr.Button("Update Parameters", variant="secondary")
         
-        with gr.Tab("File Analysis"):
+        with gr.Tab("File Analysis & JSON Conversion"):
             with gr.Row():
                 with gr.Column(scale=1):
                     file_upload = gr.File(label="Upload a file to analyze")
                     analyze_btn = gr.Button("Analyze File", variant="primary")
+                    convert_json_btn = gr.Button("Convert to n8n JSON", variant="primary")
                 
                 with gr.Column(scale=2):
-                    file_analysis_output = gr.Markdown(label="File Analysis Results")
+                    with gr.Tabs():
+                        with gr.TabItem("File Analysis"):
+                            file_analysis_output = gr.Markdown(label="File Analysis Results")
+                        with gr.TabItem("n8n JSON Output"):
+                            n8n_json_output = gr.Code(
+                                language="json",
+                                label="n8n Compatible JSON",
+                                lines=20
+                            )
+        
+        with gr.Tab("JSON Formatting Guide"):
+            gr.Markdown("""
+            # n8n JSON Formatting Guide
+            
+            This tab provides guidance on creating well-structured JSON for n8n workflows.
+            
+            ## Basic n8n Workflow Structure
+            
+            ```json
+            {
+              "name": "My Workflow",
+              "nodes": [
+                {
+                  "parameters": { /* Node-specific parameters */ },
+                  "id": "1",
+                  "name": "Start Node",
+                  "type": "n8n-nodes-base.some-node-type",
+                  "typeVersion": 1,
+                  "position": [250, 300]
+                }
+                // Additional nodes...
+              ],
+              "connections": {
+                "Start Node": {
+                  "main": [
+                    [
+                      {
+                        "node": "Second Node",
+                        "type": "main",
+                        "index": 0
+                      }
+                    ]
+                  ]
+                }
+                // Additional connections...
+              }
+            }
+            ```
+            
+            ## Tips for Creating n8n-Compatible JSON
+            
+            1. Ensure all JSON keys and values are properly quoted
+            2. Use proper nesting for workflow components
+            3. Define unique IDs for each node
+            4. Properly define connections between nodes
+            5. Include all required parameters for each node type
+            
+            Use the chat interface to ask for specific n8n node configurations or workflow patterns.
+            """)
         
         # Set up event handlers
         send_btn.click(
             generate_response, 
             inputs=[msg, chatbot], 
-            outputs=[chatbot], 
+            outputs=chatbot, 
             api_name="chat"
         )
         
         msg.submit(
             generate_response, 
             inputs=[msg, chatbot], 
-            outputs=[chatbot], 
+            outputs=chatbot, 
             api_name=False
         )
         
@@ -519,6 +729,12 @@ def create_gradio_interface():
             api_name=False
         )
         
+        convert_json_btn.click(
+            convert_to_n8n_json,
+            outputs=n8n_json_output,
+            api_name="convert_to_n8n"
+        )
+        
         chat_selector.change(
             select_chat,
             inputs=chat_selector,
@@ -543,8 +759,8 @@ def create_gradio_interface():
             api_name="clear_chat"
         )
         
-        # Refresh example messages every few seconds
-        chat_selector.change(lambda: [], outputs=chatbot)
+        # Initialize empty chatbot
+        chatbot.value = []
 
     return app