update

app.py

@@ -1,8 +1,6 @@
 import gradio as gr
 from llama_cpp import Llama
 from huggingface_hub import hf_hub_download
-import json
-import re
 
 def load_model():
     repo_id = "forestav/gguf_lora_model"
@@ -23,112 +21,113 @@ def load_model():
     
     return model
 
-# Enhanced generation with multiple modes
-def generate_response(message, history, mode='chat'):
-    # Preprocessing based on mode
-    if mode == 'code':
-        system_prompt = "You are an expert coding assistant. Provide clean, efficient code solutions."
-    elif mode == 'creative':
-        system_prompt = "You are a creative writing assistant. Generate imaginative and engaging content."
-    elif mode == 'analytical':
-        system_prompt = "You are an analytical assistant. Provide deep, structured insights and reasoning."
-    else:
-        system_prompt = "You are a helpful AI assistant."
+def generate_instructions(input_text, instruction_type, complexity, audience):
+    # Craft a comprehensive system prompt
+    system_prompt = f"""You are an expert at creating clear, precise instructions. 
+    Generate instructions that are:
+    - Type: {instruction_type}
+    - Complexity Level: {complexity}
+    - Target Audience: {audience}
     
-    # Prepare messages with system context
+    Core Input Context: {input_text}
+    
+    Guidelines:
+    - Use clear, step-by-step language
+    - Ensure instructions are actionable and specific
+    - Include safety warnings or prerequisites if relevant
+    - Adapt complexity to the specified audience level"""
+
+    # Prepare messages for instruction generation
     messages = [
         {"role": "system", "content": system_prompt},
-        *[{"role": "user" if i % 2 == 0 else "assistant", "content": msg} 
-          for i, msg in enumerate(sum(history, []))],
-        {"role": "user", "content": message}
+        {"role": "user", "content": f"Please generate comprehensive instructions for: {input_text}"}
     ]
     
     # Generate response
     response = model.create_chat_completion(
         messages=messages,
-        max_tokens=512,
+        max_tokens=1024,
         temperature=0.7,
         top_p=0.95,
     )
     
     return response['choices'][0]['message']['content']
 
-# Extract structured data from text
-def extract_structured_data(text):
-    try:
-        # Try to extract JSON-like structures
-        json_match = re.search(r'\{.*\}', text, re.DOTALL)
-        if json_match:
-            try:
-                return json.loads(json_match.group(0))
-            except json.JSONDecodeError:
-                pass
-        
-        # Fall back to custom parsing for key-value pairs
-        data = {}
-        for line in text.split('\n'):
-            if ':' in line:
-                key, value = line.split(':', 1)
-                data[key.strip()] = value.strip()
-        
-        return data
-    except Exception as e:
-        return {"error": str(e)}
+# Load model globally
+print("Starting model loading...")
+model = load_model()
+print("Model loaded successfully!")
 
-# Create Gradio interface with multiple tabs
-def create_interface():
-    with gr.Blocks() as demo:
-        gr.Markdown("# Multi-Mode AI Assistant")
-        
-        with gr.Tabs():
-            # Chat Interface
-            with gr.TabItem("Conversational Chat"):
-                chat_interface = gr.ChatInterface(
-                    fn=lambda message, history: generate_response(message, history, 'chat'),
-                    title="Conversational AI",
-                    description="General-purpose conversation mode"
-                )
+# Create Gradio interface
+demo = gr.Blocks(title="Instruction Craft AI")
+
+with demo:
+    gr.Markdown("# 📝 Instruction Crafting Assistant")
+    gr.Markdown("Generate precise, tailored instructions for any task or process.")
+    
+    with gr.Row():
+        with gr.Column():
+            input_text = gr.Textbox(label="Describe the task or process")
+            
+            instruction_type = gr.Dropdown(
+                label="Instruction Type",
+                choices=[
+                    "How-to Guide", 
+                    "Technical Manual", 
+                    "Safety Procedure", 
+                    "Educational Tutorial", 
+                    "Cooking Recipe", 
+                    "DIY Project", 
+                    "Professional Workflow"
+                ]
+            )
             
-            # Code Generation Tab
-            with gr.TabItem("Code Assistant"):
-                code_interface = gr.ChatInterface(
-                    fn=lambda message, history: generate_response(message, history, 'code'),
-                    title="AI Code Generator",
-                    description="Generate code snippets and solve programming challenges"
-                )
+            complexity = gr.Dropdown(
+                label="Complexity Level",
+                choices=[
+                    "Beginner", 
+                    "Intermediate", 
+                    "Advanced", 
+                    "Expert"
+                ]
+            )
             
-            # Creative Writing Tab
-            with gr.TabItem("Creative Writing"):
-                creative_interface = gr.ChatInterface(
-                    fn=lambda message, history: generate_response(message, history, 'creative'),
-                    title="Creative Writing Assistant",
-                    description="Generate stories, poems, and creative content"
-                )
+            audience = gr.Dropdown(
+                label="Target Audience",
+                choices=[
+                    "Children", 
+                    "Students", 
+                    "General Public", 
+                    "Professionals", 
+                    "Experts"
+                ]
+            )
             
-            # Data Extraction Tab
-            with gr.TabItem("Data Extractor"):
-                with gr.Row():
-                    text_input = gr.Textbox(label="Input Text")
-                    extract_btn = gr.Button("Extract Structured Data")
-                    json_output = gr.JSON(label="Extracted Data")
-                
-                extract_btn.click(
-                    fn=extract_structured_data, 
-                    inputs=text_input, 
-                    outputs=json_output
-                )
+            generate_btn = gr.Button("Craft Instructions", variant="primary")
+        
+        with gr.Column():
+            output_text = gr.Textbox(label="Generated Instructions", lines=20)
     
-    return demo
+    generate_btn.click(
+        fn=generate_instructions, 
+        inputs=[input_text, instruction_type, complexity, audience], 
+        outputs=output_text
+    )
 
-# Load model globally
-print("Starting model loading...")
-model = load_model()
-print("Model loaded successfully!")
+# Add some example inputs
+demo.load(
+    fn=lambda: {
+        input_text: "Change a car tire", 
+        instruction_type: "How-to Guide", 
+        complexity: "Intermediate", 
+        audience: "General Public"
+    },
+    outputs=[input_text, instruction_type, complexity, audience]
+)
 
-# Create and launch the interface
-demo = create_interface()
+# Launch the interface
 demo.launch(
-    server_name="0.0.0.0",  # Necessary for Spaces
-    server_port=7860,       # Standard port for Spaces
-    share=True            # Don't need share link in Spaces
+    server_name="0.0.0.0",
+    server_port=7860,
+    share=False
 )