Create main.app

main.app

@@ -0,0 +1,224 @@
+import gradio as gr
+import csv
+from huggingface_hub import InferenceClient
+import os
+from datetime import datetime
+import pandas as pd
+
+# Initialize the Hugging Face Inference Client
+HF_TOKEN = os.getenv("HUGGINGFACE_TOKEN")
+client = InferenceClient(token=HF_TOKEN)
+
+# Define the four models to use
+MODELS = [
+    "meta-llama/Llama-3.2-3B-Instruct",
+    "mistralai/Mistral-7B-Instruct-v0.3",
+    "google/gemma-2-2b-it",
+    "Qwen/Qwen2.5-7B-Instruct"
+]
+
+def get_llm_response(model_name, prompt, max_tokens=500, temperature=0.7):
+    """
+    Get response from a specific LLM model.
+    Each call is independent with no conversation history.
+    """
+    try:
+        # Create a fresh client for each request to ensure no state persistence
+        fresh_client = InferenceClient(token=HF_TOKEN)
+        
+        # Only send the current prompt - no conversation history
+        response = fresh_client.chat_completion(
+            model=model_name,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=max_tokens,
+            temperature=temperature
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def collect_responses(prompt_text, max_tokens=500, temperature=0.7):
+    """
+    Collect responses from all four models for a given prompt
+    and return as a dataframe and CSV file.
+    Each model gets a fresh, independent query with no history.
+    """
+    results = []
+    status_updates = []
+    
+    for model in MODELS:
+        status_updates.append(f"⏳ Querying {model}...")
+        yield "\n".join(status_updates), None, None
+        
+        response = get_llm_response(model, prompt_text, max_tokens, temperature)
+        
+        result = {
+            'timestamp': datetime.now().isoformat(),
+            'prompt': prompt_text,
+            'model': model,
+            'response': response
+        }
+        results.append(result)
+        
+        status_updates[-1] = f"✓ Completed {model}"
+        yield "\n".join(status_updates), None, None
+    
+    # Create DataFrame
+    df = pd.DataFrame(results)
+    
+    # Save to CSV
+    csv_filename = f"llm_responses_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+    df.to_csv(csv_filename, index=False)
+    
+    status_updates.append(f"\n✅ All responses collected! Saved to {csv_filename}")
+    
+    yield "\n".join(status_updates), df, csv_filename
+
+def batch_collect_responses(prompts_text, max_tokens=500, temperature=0.7):
+    """
+    Collect responses for multiple prompts (one per line).
+    Each prompt is processed independently with no conversation history.
+    """
+    prompts = [p.strip() for p in prompts_text.split('\n') if p.strip()]
+    
+    if not prompts:
+        return "❌ Please enter at least one prompt", None, None
+    
+    all_results = []
+    status_updates = []
+    
+    for i, prompt in enumerate(prompts, 1):
+        status_updates.append(f"\n📝 Processing prompt {i}/{len(prompts)}: {prompt[:50]}...")
+        yield "\n".join(status_updates), None, None
+        
+        for model in MODELS:
+            status_updates.append(f"  ⏳ Querying {model}...")
+            yield "\n".join(status_updates), None, None
+            
+            response = get_llm_response(model, prompt, max_tokens, temperature)
+            
+            result = {
+                'timestamp': datetime.now().isoformat(),
+                'prompt': prompt,
+                'model': model,
+                'response': response
+            }
+            all_results.append(result)
+            
+            status_updates[-1] = f"  ✓ Completed {model}"
+            yield "\n".join(status_updates), None, None
+    
+    # Create DataFrame
+    df = pd.DataFrame(all_results)
+    
+    # Save to CSV
+    csv_filename = f"llm_responses_batch_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+    df.to_csv(csv_filename, index=False)
+    
+    status_updates.append(f"\n✅ All responses collected! Saved to {csv_filename}")
+    
+    yield "\n".join(status_updates), df, csv_filename
+
+# Create Gradio interface
+with gr.Blocks(title="Multi-LLM Response Collector") as demo:
+    gr.Markdown("""
+    # 🤖 Multi-LLM Response Collector
+    
+    Collect and compare **one-shot** responses from four different LLMs:
+    - Meta Llama 3.2 3B
+    - Mistral 7B
+    - Google Gemma 2 2B
+    - Qwen 2.5 7B
+    
+    **Important:** Each query is independent with no conversation history. 
+    Every prompt gets a fresh response with zero context from previous queries.
+    
+    Responses are saved to a CSV file for easy analysis.
+    """)
+    
+    with gr.Tab("Single Prompt"):
+        with gr.Row():
+            with gr.Column():
+                prompt_input = gr.Textbox(
+                    label="Enter your prompt",
+                    placeholder="e.g., What is artificial intelligence?",
+                    lines=3
+                )
+                max_tokens_single = gr.Slider(
+                    minimum=100,
+                    maximum=1000,
+                    value=500,
+                    step=50,
+                    label="Max Tokens"
+                )
+                temperature_single = gr.Slider(
+                    minimum=0.0,
+                    maximum=2.0,
+                    value=0.7,
+                    step=0.1,
+                    label="Temperature (creativity)"
+                )
+                submit_btn = gr.Button("Collect Responses", variant="primary")
+            
+        status_output = gr.Textbox(label="Status", lines=6)
+        
+        with gr.Row():
+            df_output = gr.Dataframe(label="Responses")
+            
+        csv_output = gr.File(label="Download CSV")
+        
+        submit_btn.click(
+            fn=collect_responses,
+            inputs=[prompt_input, max_tokens_single, temperature_single],
+            outputs=[status_output, df_output, csv_output]
+        )
+    
+    with gr.Tab("Batch Prompts"):
+        with gr.Row():
+            with gr.Column():
+                batch_input = gr.Textbox(
+                    label="Enter prompts (one per line)",
+                    placeholder="What is AI?\nExplain machine learning.\nWhat is deep learning?",
+                    lines=5
+                )
+                max_tokens_batch = gr.Slider(
+                    minimum=100,
+                    maximum=1000,
+                    value=500,
+                    step=50,
+                    label="Max Tokens"
+                )
+                temperature_batch = gr.Slider(
+                    minimum=0.0,
+                    maximum=2.0,
+                    value=0.7,
+                    step=0.1,
+                    label="Temperature (creativity)"
+                )
+                batch_btn = gr.Button("Collect Batch Responses", variant="primary")
+        
+        batch_status = gr.Textbox(label="Status", lines=10)
+        
+        with gr.Row():
+            batch_df = gr.Dataframe(label="All Responses")
+            
+        batch_csv = gr.File(label="Download CSV")
+        
+        batch_btn.click(
+            fn=batch_collect_responses,
+            inputs=[batch_input, max_tokens_batch, temperature_batch],
+            outputs=[batch_status, batch_df, batch_csv]
+        )
+    
+    gr.Markdown("""
+    ---
+    ### 📊 CSV Format
+    The output CSV contains:
+    - `timestamp`: When the response was generated
+    - `prompt`: The input prompt
+    - `model`: Which model generated the response
+    - `response`: The model's response
+    """)
+
+if __name__ == "__main__":
+    demo.launch()