Upload 2 files

app.py

@@ -0,0 +1,294 @@
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+import torch
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import json
+import time
+from datetime import datetime
+
+# Configuration for different agent types
+AGENT_CONFIGS = {
+    "researcher": {
+        "model": "HuggingFaceH4/zephyr-7b-beta",
+        "role": "Research and gather information",
+        "prompt_template": "You are a research agent. Analyze and provide detailed information about: {task}"
+    },
+    "coder": {
+        "model": "Salesforce/codegen-350M-mono",
+        "role": "Generate and explain code",
+        "prompt_template": "Generate Python code for: {task}"
+    },
+    "analyzer": {
+        "model": "HuggingFaceH4/zephyr-7b-beta",
+        "role": "Analyze data and provide insights",
+        "prompt_template": "Analyze the following and provide insights: {task}"
+    },
+    "writer": {
+        "model": "HuggingFaceH4/zephyr-7b-beta",
+        "role": "Create content and documentation",
+        "prompt_template": "Write professional content about: {task}"
+    }
+}
+
+class AgentSystem:
+    def __init__(self):
+        self.models = {}
+        self.tokenizers = {}
+        self.executor = ThreadPoolExecutor(max_workers=4)
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+        
+    def load_model(self, agent_name, model_name):
+        """Load model for specific agent"""
+        if agent_name not in self.models:
+            print(f"Loading {agent_name} model: {model_name}")
+            try:
+                self.tokenizers[agent_name] = AutoTokenizer.from_pretrained(model_name)
+                self.models[agent_name] = AutoModelForCausalLM.from_pretrained(
+                    model_name,
+                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                    low_cpu_mem_usage=True,
+                    device_map="auto" if self.device == "cuda" else None
+                )
+                print(f"{agent_name} model loaded successfully!")
+            except Exception as e:
+                print(f"Error loading {agent_name} model: {e}")
+                # Fallback to smaller model
+                print(f"Falling back to distilgpt2 for {agent_name}")
+                self.tokenizers[agent_name] = AutoTokenizer.from_pretrained("distilgpt2")
+                self.models[agent_name] = AutoModelForCausalLM.from_pretrained("distilgpt2")
+    
+    def generate_response(self, agent_name, prompt, max_length=200):
+        """Generate response for a specific agent"""
+        try:
+            config = AGENT_CONFIGS[agent_name]
+            model_name = config["model"]
+            
+            # Load model if not already loaded
+            if agent_name not in self.models:
+                self.load_model(agent_name, model_name)
+            
+            tokenizer = self.tokenizers[agent_name]
+            model = self.models[agent_name]
+            
+            # Format prompt
+            formatted_prompt = config["prompt_template"].format(task=prompt)
+            
+            # Tokenize
+            inputs = tokenizer(formatted_prompt, return_tensors="pt", truncation=True, max_length=512)
+            
+            if self.device == "cuda":
+                inputs = inputs.to("cuda")
+            
+            # Generate
+            with torch.no_grad():
+                outputs = model.generate(
+                    inputs.input_ids,
+                    max_length=max_length,
+                    temperature=0.7,
+                    top_p=0.9,
+                    do_sample=True,
+                    pad_token_id=tokenizer.eos_token_id
+                )
+            
+            response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            return {
+                "agent": agent_name,
+                "role": config["role"],
+                "response": response,
+                "status": "success"
+            }
+            
+        except Exception as e:
+            return {
+                "agent": agent_name,
+                "role": AGENT_CONFIGS[agent_name]["role"],
+                "response": f"Error: {str(e)}",
+                "status": "error"
+            }
+    
+    def run_agents_parallel(self, task, selected_agents, max_length=200):
+        """Run multiple agents in parallel"""
+        start_time = time.time()
+        futures = {}
+        results = []
+        
+        # Submit tasks to thread pool
+        for agent_name in selected_agents:
+            future = self.executor.submit(
+                self.generate_response,
+                agent_name,
+                task,
+                max_length
+            )
+            futures[future] = agent_name
+        
+        # Collect results as they complete
+        for future in as_completed(futures):
+            agent_name = futures[future]
+            try:
+                result = future.result()
+                result["time_taken"] = round(time.time() - start_time, 2)
+                results.append(result)
+            except Exception as e:
+                results.append({
+                    "agent": agent_name,
+                    "role": AGENT_CONFIGS[agent_name]["role"],
+                    "response": f"Failed: {str(e)}",
+                    "status": "error",
+                    "time_taken": round(time.time() - start_time, 2)
+                })
+        
+        total_time = round(time.time() - start_time, 2)
+        return results, total_time
+
+# Initialize the agent system
+print("Initializing AI Agent System...")
+agent_system = AgentSystem()
+
+def process_task(task, researcher, coder, analyzer, writer, max_length):
+    """Process task with selected agents"""
+    if not task.strip():
+        return "Please enter a task!", ""
+    
+    # Determine which agents to use
+    selected_agents = []
+    if researcher:
+        selected_agents.append("researcher")
+    if coder:
+        selected_agents.append("coder")
+    if analyzer:
+        selected_agents.append("analyzer")
+    if writer:
+        selected_agents.append("writer")
+    
+    if not selected_agents:
+        return "Please select at least one agent!", ""
+    
+    # Run agents in parallel
+    results, total_time = agent_system.run_agents_parallel(task, selected_agents, max_length)
+    
+    # Format output
+    output = f"# 🤖 AI Agent System Results\n\n"
+    output += f"**Task:** {task}\n\n"
+    output += f"**Agents Used:** {len(selected_agents)} agents running in parallel\n\n"
+    output += f"**Total Time:** {total_time}s\n\n"
+    output += "---\n\n"
+    
+    for result in results:
+        status_emoji = "✅" if result["status"] == "success" else "❌"
+        output += f"## {status_emoji} {result['agent'].upper()} Agent\n"
+        output += f"**Role:** {result['role']}\n\n"
+        output += f"**Response:**\n```\n{result['response']}\n```\n\n"
+        output += f"*Completed in {result['time_taken']}s*\n\n"
+        output += "---\n\n"
+    
+    # Create summary
+    summary = {
+        "task": task,
+        "agents_used": len(selected_agents),
+        "total_time": total_time,
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    return output, json.dumps(summary, indent=2)
+
+# Create Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft(), title="AI Agent System") as demo:
+    gr.Markdown(
+        """
+        # 🤖 Full-Stack AI Agent System
+        
+        **Parallel AI Processing with Multiple Specialized Agents**
+        
+        This system runs multiple AI agents simultaneously to process your tasks faster!
+        Each agent specializes in different areas and works in parallel.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📋 Task Input")
+            task_input = gr.Textbox(
+                label="Enter Your Task",
+                placeholder="Example: Create a Python web scraper for news articles",
+                lines=4
+            )
+            
+            gr.Markdown("### 🎯 Select Agents")
+            researcher_check = gr.Checkbox(label="🔍 Researcher Agent", value=True, info="Research and gather information")
+            coder_check = gr.Checkbox(label="💻 Coder Agent", value=True, info="Generate and explain code")
+            analyzer_check = gr.Checkbox(label="📊 Analyzer Agent", value=True, info="Analyze and provide insights")
+            writer_check = gr.Checkbox(label="✍️ Writer Agent", value=True, info="Create documentation")
+            
+            max_length = gr.Slider(
+                minimum=100,
+                maximum=500,
+                value=200,
+                step=50,
+                label="Max Response Length",
+                info="Tokens per agent"
+            )
+            
+            process_btn = gr.Button("🚀 Run Agents in Parallel", variant="primary", size="lg")
+            
+            gr.Markdown(
+                """
+                ### 💡 Tips
+                - Select multiple agents for comprehensive results
+                - Agents run simultaneously for faster processing
+                - Each agent brings unique expertise
+                """
+            )
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### 📤 Agent Outputs")
+            output_display = gr.Markdown(label="Results")
+            
+            with gr.Accordion("📊 Execution Summary", open=False):
+                summary_json = gr.Code(label="JSON Summary", language="json")
+    
+    gr.Markdown("### 📚 Example Tasks")
+    gr.Examples(
+        examples=[
+            ["Create a REST API for user authentication"],
+            ["Build a machine learning model for sentiment analysis"],
+            ["Design a database schema for an e-commerce platform"],
+            ["Write a technical blog post about microservices"],
+            ["Develop a real-time chat application"]
+        ],
+        inputs=task_input
+    )
+    
+    gr.Markdown(
+        """
+        ---
+        
+        ## 🏗️ System Architecture
+        
+        - **Parallel Processing**: All agents run simultaneously using ThreadPoolExecutor
+        - **Free Models**: Using Hugging Face hosted models (Zephyr-7B, CodeGen)
+        - **Specialized Agents**: Each agent has a specific role and expertise
+        - **Fault Tolerant**: Continues even if one agent fails
+        
+        ## 🔧 Technology Stack
+        
+        - **Frontend**: Gradio
+        - **Backend**: Python + Transformers
+        - **Models**: Hugging Face free models
+        - **Concurrency**: ThreadPoolExecutor for parallel processing
+        """
+    )
+    
+    # Connect button to processing function
+    process_btn.click(
+        fn=process_task,
+        inputs=[task_input, researcher_check, coder_check, analyzer_check, writer_check, max_length],
+        outputs=[output_display, summary_json]
+    )
+
+# Launch
+if __name__ == "__main__":
+    demo.queue()  # Enable queuing for better performance
+    demo.launch()

requirements.txt

@@ -0,0 +1,8 @@
+gradio==4.16.0
+transformers==4.36.2
+torch==2.1.2
+accelerate==0.25.0
+sentencepiece==0.1.99
+protobuf==3.20.3
+bitsandbytes==0.41.3
+scipy==1.11.4