C

app/controllers/f5_model.py

@@ -1,92 +1,114 @@
-from typing import List, Optional
-from pydantic import BaseModel
-import torch
 import logging
 from transformers import pipeline
+import asyncio
 
-class F5ModelHandler:
+class TextGenerationHandler:
     def __init__(self):
-        logging.info("Initializing F5ModelHandler...")
-        try:
-            # Using a larger T5 model for better generation
-            logging.info("Loading model 'google/flan-t5-base'...")
-            self.model_name = "google/flan-t5-large"  # Upgraded from small to large
-            
-            # Use pipeline for simpler model loading with better parameters
-            self.generator = pipeline(
-                "text2text-generation",
-                model=self.model_name,
-                device="cuda" if torch.cuda.is_available() else "cpu",
-                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                model_kwargs={"cache_dir": "./model_cache"}  # Cache the model locally
-            )
-            logging.info(f"Model loaded successfully on {self.generator.device}")
-        except Exception as e:
-            logging.error(f"Error loading model: {str(e)}")
-            raise
+        # Initialize the text generation pipeline
+        self.pipe = pipeline(
+            "text2text-generation",
+            model="google/flan-t5-small",
+            max_length=2048,  # Increase max length for longer responses
+            num_return_sequences=1
+        )
+        self.logger = logging.getLogger(__name__)
+    
+    async def generate_response(self, prompt: str) -> str:
+        """
+        Generate a complete response using the T5 model pipeline
         
-    async def generate_response(self, prompt: str, max_length: int = 3072) -> str:
-        try:
-            logging.info(f"Generating response for prompt: {prompt[:100]}...")
-            
-            # Enhanced generation parameters for better quality
-            response = self.generator(
-                prompt,
-                max_length=max_length,
-                min_length=1000,  # Ensure minimum length
-                num_beams=5,
-                temperature=0.8,
-                top_p=0.95,
-                top_k=50,
-                repetition_penalty=1.2,
-                length_penalty=1.0,
-                do_sample=True,
-                num_return_sequences=1,
-                early_stopping=True
-            )[0]['generated_text']
+        Args:
+            prompt (str): Input text to generate from
             
-            # Clean up the response
-            response = response.strip()
+        Returns:
+            str: Generated text output
+        """
+        try:
+            # Break down the generation into sections for better coherence
+            sections = [
+                "1. Executive Summary",
+                "2. Project Scope and Objectives",
+                "3. Architecture Overview",
+                "4. Component Design",
+                "5. Security and Compliance",
+                "6. Deployment Strategy",
+                "7. Team Requirements",
+                "8. Cost Estimates",
+                "9. Project Timeline"
+            ]
             
-            # Ensure minimum content length
-            if len(response) < 500:  # Increased minimum length requirement
-                logging.warning("Response too short, regenerating...")
-                return await self.generate_response(prompt, max_length)
+            complete_response = []
+            for section in sections:
+                section_prompt = f"{prompt}\nGenerate content for: {section}"
+                self.logger.info(f"Generating section: {section}")
+                self.logger.debug(f"Section prompt: {section_prompt}")
+                
+                output = self.pipe(
+                    section_prompt,
+                    max_length=512,
+                    do_sample=True,
+                    temperature=0.7,
+                    repetition_penalty=1.2,
+                    no_repeat_ngram_size=3
+                )
+                
+                section_text = output[0]['generated_text'].strip()
+                self.logger.info(f"Generated text for {section}:\n{section_text}\n")
+                
+                complete_response.append(f"{section}\n{section_text}")
             
-            logging.info(f"Generated response successfully: {response[:100]}...")
-            return response
+            final_response = "\n\n".join(complete_response)
+            self.logger.info(f"Complete response:\n{final_response}")
+            return final_response
             
         except Exception as e:
-            logging.error(f"Error generating response: {str(e)}")
+            self.logger.error(f"Error generating text: {str(e)}", exc_info=True)
             raise
 
-    async def stream_response(self, prompt: str, max_length: int = 3072):
+    async def stream_response(self, prompt: str):
+        """
+        Stream the generated response section by section
+        
+        Args:
+            prompt (str): Input text to generate from
+            
+        Yields:
+            dict: Response chunks with type and content
+        """
         try:
-            response = self.generator(
-                prompt,
-                max_length=max_length,
-                min_length=1000,
-                num_beams=4,
-                temperature=0.8,
-                top_p=0.95,
-                do_sample=True,
-                return_full_text=False
-            )[0]['generated_text']
+            # Generate complete response first
+            response = await self.generate_response(prompt)
             
-            # Simulate streaming by yielding chunks of the response
-            chunk_size = 20
-            for i in range(0, len(response), chunk_size):
-                chunk = response[i:i + chunk_size]
-                yield chunk
-
+            # Stream each section
+            accumulated_response = ""
+            sections = response.split('\n\n')
+            
+            for section in sections:
+                accumulated_response += section + "\n\n"
+                self.logger.debug(f"Streaming section:\n{section}\n")
+                
+                yield {
+                    "type": "content",
+                    "content": accumulated_response.strip()
+                }
+                await asyncio.sleep(0.1)
+                    
         except Exception as e:
-            logging.error(f"Error in stream_response: {str(e)}")
-            raise
+            self.logger.error(f"Error in stream_response: {str(e)}", exc_info=True)
+            yield {
+                "type": "error",
+                "content": str(e)
+            }
 
-# Initialize the model handler
+# Configure logging
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('f5_model.log')
+    ]
 )
 
-f5_model = F5ModelHandler()
+f5_model = TextGenerationHandler()
+

app/main.py

@@ -3,10 +3,11 @@ from fastapi.responses import StreamingResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from pydantic import BaseModel
-from app.controllers.f5_model import F5ModelHandler
+from app.controllers.f5_model import TextGenerationHandler
 from typing import List, Optional
 import logging
 from app.helpers.plan_parser import parse_plan_sections
+import json
 
 # Configure logging
 logging.basicConfig(
@@ -23,7 +24,7 @@ app = FastAPI(title="F5 Model Test Application")
 templates = Jinja2Templates(directory="app/templates")
 
 # Initialize the F5 model
-model_handler = F5ModelHandler()
+model_handler = TextGenerationHandler()
 
 class ChatMessage(BaseModel):
     role: str
@@ -190,57 +191,94 @@ async def generate_plan(request: ProjectPlanRequest):
     try:
         logger.info(f"Plan generation request received for project: {request.project_title}")
         
-        # Simplified prompt for better generation
-        prompt = f"""Create a detailed technical project plan for a {request.platform} project named '{request.project_title}'.
-
-Requirements: {request.requirements}
-Features: {', '.join(request.features)}
-Additional Requirements: {request.additional_requirements}
+        async def generate():
+            features_list = request.features
+            if features_list and isinstance(features_list[0], dict):
+                features_str = ', '.join([f.get('feature', '') for f in features_list])
+            else:
+                features_str = ', '.join(features_list)
 
-Generate a complete plan with the following sections:
+            prompt = f"""As a technical project planner, create a detailed project plan for a {request.platform} SaaS application named '{request.project_title}'. 
+            Follow this structure exactly, replacing the placeholders with detailed content:
 
 1. Executive Summary
-Brief overview of the project, its goals, and business impact.
+Brief overview of the {request.project_title} SaaS application
+Key business objectives
+Technical approach using {request.platform}
+Expected outcomes
 
 2. Project Scope and Objectives
-Core functionalities and specific objectives.
+Core Features:
+- {features_str}
+Technical Goals:
+- Scalable {request.platform} architecture
+- Secure data handling
+- High availability
 
 3. Architecture Overview
-{request.platform} architecture components and their interactions.
+{request.platform} Components:
+- Frontend: [Specify technology]
+- Backend: [Specify {request.platform} services]
+- Database: [Specify database solution]
+- Storage: [Specify storage solution]
+- Authentication: [Specify auth service]
 
 4. Component Design
-Core components and their technical specifications.
+[For each major component, specify:
+- Technical specifications
+- Integration points
+- Performance requirements]
 
 5. Security and Compliance
-Security measures and compliance requirements.
+{request.platform}-specific security measures:
+- Data encryption
+- Access controls
+- Compliance requirements
 
-6. Deployment, Testing, and Monitoring
-Implementation approach and quality assurance.
+6. Deployment Strategy
+- CI/CD pipeline
+- Testing approach
+- Monitoring setup
+- {request.platform} specific considerations
 
-7. Team Roles and Skills
-Required team members and their expertise.
+7. Team Requirements
+- Required roles
+- Technical skills
+- Team structure
 
-8. Cost Estimates and Optimization
-Resource planning and cost optimization.
+8. Cost Estimation
+- {request.platform} service costs
+- Development costs
+- Operational costs
 
-9. Project Tasks and Milestones
-Project phases and timeline.
+9. Project Timeline
+Phase 1: Setup and Infrastructure
+Phase 2: Core Development
+Phase 3: Testing and Deployment
+Phase 4: Launch and Monitoring
 
-Provide detailed content for each section."""
-        
-        logger.info("Generating plan with model...")
-        response = await model_handler.generate_response(prompt)
-        logger.info(f"Response generated successfully: {response[:100]}...")
-        
-        # Parse the response into structured sections
-        sections = parse_plan_sections(response)
-        
-        logger.info("Plan generated successfully")
-        return {
-            "project_title": request.project_title,
-            "sections": sections,
-            "raw_content": response
-        }
+Additional Context:
+Requirements: {request.requirements}
+Additional Requirements: {request.additional_requirements}"""
+
+            response_content = ""
+            async for chunk in model_handler.stream_response(prompt):
+                if chunk["type"] == "content":
+                    response_content = chunk["content"]
+                    sections = parse_plan_sections(response_content)
+                    yield f"data: {json.dumps({
+                        'type': 'complete',
+                        'project_title': request.project_title,
+                        'sections': sections,
+                        'raw_content': response_content
+                    })}\n\n"
+                elif chunk["type"] == "error":
+                    yield f"data: {json.dumps({
+                        'type': 'error',
+                        'content': chunk['content']
+                    })}\n\n"
+
+        return StreamingResponse(generate(), media_type="text/event-stream")
         
     except Exception as e:
         logger.error(f"Error generating plan: {str(e)}", exc_info=True)

app/templates/index.html

@@ -218,36 +218,7 @@
             </div>
         </div>
 
-        <!-- Add this right after the form -->
-        <div id="rawOutput" class="mt-8 bg-white rounded-lg shadow-lg p-6">
-            <h2 class="text-xl font-bold mb-4 text-gray-800">Raw Response Data</h2>
-            
-            <div class="space-y-6">
-                <!-- Request Data -->
-                <div class="bg-gray-50 p-4 rounded-lg">
-                    <h3 class="text-lg font-semibold mb-2 text-blue-600">Request Data</h3>
-                    <pre id="rawRequest" class="bg-gray-900 text-green-400 p-4 rounded overflow-auto max-h-60 font-mono text-sm whitespace-pre-wrap"></pre>
-                </div>
-
-                <!-- API Response -->
-                <div class="bg-gray-50 p-4 rounded-lg">
-                    <h3 class="text-lg font-semibold mb-2 text-blue-600">API Response</h3>
-                    <pre id="rawApiResponse" class="bg-gray-900 text-green-400 p-4 rounded overflow-auto max-h-96 font-mono text-sm whitespace-pre-wrap"></pre>
-                </div>
-
-                <!-- Raw Content -->
-                <div class="bg-gray-50 p-4 rounded-lg">
-                    <h3 class="text-lg font-semibold mb-2 text-blue-600">Raw Content</h3>
-                    <pre id="rawContent" class="bg-gray-900 text-green-400 p-4 rounded overflow-auto max-h-96 font-mono text-sm whitespace-pre-wrap"></pre>
-                </div>
-
-                <!-- Parsed Sections -->
-                <div class="bg-gray-50 p-4 rounded-lg">
-                    <h3 class="text-lg font-semibold mb-2 text-blue-600">Parsed Sections</h3>
-                    <pre id="rawSections" class="bg-gray-900 text-green-400 p-4 rounded overflow-auto max-h-96 font-mono text-sm whitespace-pre-wrap"></pre>
-                </div>
-            </div>
-        </div>
+ 
     </div>
 
     <!-- Chat Widget -->
@@ -297,6 +268,7 @@
     <script>
         let chatHistory = [];
         let chatWindowOpen = false;
+        let accumulatedContent = '';
 
         function toggleChat() {
             const chatWindow = document.getElementById('chatWindow');
@@ -458,8 +430,7 @@
                 additional_requirements: additionalRequirements
             };
 
-            // Display request data
-            document.getElementById('rawRequest').textContent = JSON.stringify(requestData, null, 2);
+            console.log('Request Data:', requestData);
 
             const loading = document.getElementById('planLoading');
             const output = document.getElementById('planOutput');
@@ -467,31 +438,38 @@
             output.classList.add('hidden');
 
             try {
+                console.log('Starting plan generation request...');
                 const response = await fetch('/generate-plan', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
                     body: JSON.stringify(requestData)
                 });
 
+                console.log('Got response, starting reader...');
                 const reader = response.body.getReader();
                 const decoder = new TextDecoder();
 
-                // Show progress bar
                 document.getElementById('progressBar').classList.remove('hidden');
+                console.log('Progress bar shown');
 
                 while (true) {
                     const { value, done } = await reader.read();
-                    if (done) break;
+                    if (done) {
+                        console.log('Stream complete');
+                        break;
+                    }
 
                     const chunk = decoder.decode(value);
+                    console.log('Received chunk:', chunk);
+                    
                     const lines = chunk.split('\n');
-
                     for (const line of lines) {
                         if (line.startsWith('data: ')) {
                             const data = JSON.parse(line.slice(5));
+                            console.log('Parsed data:', data);
                             
                             if (data.type === 'progress') {
-                                // Update progress bar
+                                console.log('Progress update:', data.progress + '%');
                                 const progressFill = document.getElementById('progressFill');
                                 const progressText = document.getElementById('progressText');
                                 const progressStep = document.getElementById('progressStep');
@@ -500,13 +478,12 @@
                                 progressText.textContent = `${Math.round(data.progress)}%`;
                                 progressStep.textContent = `Step ${data.step}/${data.total}`;
                             } else if (data.type === 'complete') {
-                                // Display final results
+                                accumulatedContent += data.raw_content;
+                                data.sections = parseSections(accumulatedContent);
+                                console.log('Generation complete, displaying plan with content:', accumulatedContent);
                                 displayPlan(data);
-                                document.getElementById('rawApiResponse').textContent = JSON.stringify(data, null, 2);
-                                document.getElementById('rawContent').textContent = data.raw_content;
-                                document.getElementById('rawSections').textContent = JSON.stringify(data.sections, null, 2);
                             } else if (data.type === 'error') {
-                                console.error('Error:', data.error);
+                                console.error('Error in generation:', data.error);
                                 alert(`Error: ${data.error}`);
                             }
                         }
@@ -514,11 +491,11 @@
                 }
 
             } catch (error) {
-                console.error('Error:', error);
+                console.error('Error in generatePlan:', error);
                 alert('Error generating plan');
             } finally {
+                console.log('Cleaning up...');
                 loading.style.display = 'none';
-                // Hide progress bar when done
                 document.getElementById('progressBar').classList.add('hidden');
             }
         }
@@ -540,38 +517,86 @@
             const title = document.getElementById('planTitle');
             const sections = document.getElementById('planSections');
 
-            // Update debug panel with raw data
-            document.getElementById('requestData').textContent = JSON.stringify({
-                project_title: data.project_title,
-                sections: data.sections
-            }, null, 2);
+            try {
+                // Update debug panel with raw data
+                document.getElementById('requestData').textContent = JSON.stringify({
+                    project_title: data.project_title,
+                    sections: data.sections
+                }, null, 2);
+
+                // Display raw content with line breaks preserved
+                const rawContent = document.getElementById('rawContent');
+                rawContent.textContent = data.raw_content;
+                
+                // Show content length
+                const contentLength = data.raw_content.length;
+                document.getElementById('rawContentLength').textContent = 
+                    `Length: ${contentLength} characters`;
+
+                // Display parsed sections
+                document.getElementById('parsedSections').textContent = 
+                    JSON.stringify(data.sections, null, 2);
+
+                // Original plan display code
+                title.textContent = `Technical Project Plan: ${data.project_title}`;
+                sections.innerHTML = '';
 
-            // Display raw content with line breaks preserved
-            const rawContent = document.getElementById('rawContent');
-            rawContent.textContent = data.raw_content;
+                output.classList.remove('hidden'); // Show the output section instead of hiding it
+            } catch (error) {
+                console.error('Error in displayPlan:', error);
+                alert('Error displaying plan. Check console for details.');
+            }
+        }
+
+        function parseSections(content) {
+            const sections = {
+                "executive_summary": "",
+                "scope_objectives": "",
+                "architecture_overview": "",
+                "component_design": "",
+                "security_compliance": "",
+                "deployment_testing": "",
+                "team_roles": "",
+                "cost_estimates": "",
+                "project_phases": ""
+            };
+
+            let currentSection = null;
+            const lines = content.split('\n');
             
-            // Show content length
-            const contentLength = data.raw_content.length;
-            document.getElementById('rawContentLength').textContent = 
-                `Length: ${contentLength} characters`;
-
-            // Display parsed sections
-            document.getElementById('parsedSections').textContent = 
-                JSON.stringify(data.sections, null, 2);
-
-            // Original plan display code
-            title.textContent = `Technical Project Plan: ${data.project_title}`;
-            sections.innerHTML = '';
-
-            // Keep only debug panel toggle functionality
-            document.addEventListener('keydown', function(e) {
-                if (e.ctrlKey && e.key === 'd') {
-                    e.preventDefault();
-                    toggleDebugPanel();
+            for (const line of lines) {
+                if (line.startsWith('1. Executive Summary')) {
+                    currentSection = "executive_summary";
+                } else if (line.startsWith('2. Project Scope and Objectives')) {
+                    currentSection = "scope_objectives";
+                } else if (line.startsWith('3. Architecture Overview')) {
+                    currentSection = "architecture_overview";
+                } else if (line.startsWith('4. Component Design')) {
+                    currentSection = "component_design";
+                } else if (line.startsWith('5. Security and Compliance')) {
+                    currentSection = "security_compliance";
+                } else if (line.startsWith('6. Deployment and Testing')) {
+                    currentSection = "deployment_testing";
+                } else if (line.startsWith('7. Team Roles')) {
+                    currentSection = "team_roles";
+                } else if (line.startsWith('8. Cost Estimates')) {
+                    currentSection = "cost_estimates";
+                } else if (line.startsWith('9. Project Phases')) {
+                    currentSection = "project_phases";
+                } else if (currentSection && line.trim()) {
+                    sections[currentSection] += line + '\n';
+                }
+            }
+
+            // Trim any trailing whitespace from sections
+            Object.keys(sections).forEach(key => {
+                sections[key] = sections[key].trim();
+                if (!sections[key]) {
+                    sections[key] = "No content generated";
                 }
             });
 
-            output.classList.add('hidden');  // Hide the output section
+            return sections;
         }
     </script>
 </body>