Update app.py

app.py

@@ -2,7 +2,7 @@ import streamlit as st
 import os
 import requests
 import hashlib
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional, Mapping
 from datetime import datetime
 import json
 import re
@@ -11,7 +11,6 @@ import time
 import random
 import markdown
 
-# Import required libraries
 from crewai import Agent, Task, Crew, Process
 from crewai.tools import BaseTool
 from groq import Groq
@@ -35,11 +34,8 @@ class AcademicResearchTool(BaseTool):
     description: str = "Conduct comprehensive academic research for thesis/synopsis"
 
     def _run(self, topic: str, research_areas: str) -> str:
-        """Conduct thorough academic research"""
         try:
             time.sleep(1)
-            
-            # Create multiple search queries for comprehensive research
             search_queries = [
                 f"{topic} research studies",
                 f"{topic} academic papers",
@@ -47,9 +43,7 @@ class AcademicResearchTool(BaseTool):
                 f"{topic} methodology",
                 f"{topic} literature review"
             ]
-            
             all_research = []
-            
             with DDGS() as ddgs:
                 for query in search_queries:
                     try:
@@ -62,39 +56,30 @@ class AcademicResearchTool(BaseTool):
                                 'url': result.get('href', ''),
                                 'relevance_score': self._calculate_relevance(result.get('body', ''), topic)
                             })
-                        time.sleep(0.5)  # Rate limiting
-                    except Exception as e:
+                        time.sleep(0.5)
+                    except Exception:
                         continue
-            
-            # Sort by relevance and remove duplicates
             unique_research = self._remove_duplicates(all_research)
             unique_research.sort(key=lambda x: x['relevance_score'], reverse=True)
-            
-            return json.dumps(unique_research[:15])  # Top 15 most relevant sources
+            return json.dumps(unique_research[:15])
         except Exception as e:
             return f"Research failed: {str(e)}"
 
     def _calculate_relevance(self, content: str, topic: str) -> float:
-        """Calculate relevance score for research content"""
         topic_words = set(topic.lower().split())
         content_words = set(content.lower().split())
-        
         if not topic_words or not content_words:
             return 0.0
-        
         intersection = topic_words.intersection(content_words)
         return len(intersection) / len(topic_words)
 
     def _remove_duplicates(self, research_list: List[Dict]) -> List[Dict]:
-        """Remove duplicate research entries"""
         seen_urls = set()
         unique_research = []
-        
         for item in research_list:
             if item['url'] not in seen_urls:
                 seen_urls.add(item['url'])
                 unique_research.append(item)
-        
         return unique_research
 
 class CitationGeneratorTool(BaseTool):
@@ -102,19 +87,13 @@ class CitationGeneratorTool(BaseTool):
     description: str = "Generate proper academic citations and references"
 
     def _run(self, research_data: str) -> str:
-        """Generate academic citations from research data"""
         try:
             research_items = json.loads(research_data)
             citations = []
-            
-            for i, item in enumerate(research_items[:10]):  # Top 10 sources
-                # Generate citation in APA format
+            for i, item in enumerate(research_items[:10]):
                 title = item.get('title', 'Unknown Title')
                 url = item.get('url', '')
-                
-                # Extract domain for author/organization
                 domain = url.split('/')[2] if len(url.split('/')) > 2 else 'Unknown'
-                
                 citation = {
                     'id': f"source_{i+1}",
                     'title': title,
@@ -124,7 +103,6 @@ class CitationGeneratorTool(BaseTool):
                     'in_text': f"({domain}, {datetime.now().year})"
                 }
                 citations.append(citation)
-            
             return json.dumps(citations)
         except Exception as e:
             return f"Citation generation failed: {str(e)}"
@@ -134,46 +112,35 @@ class AcademicWritingTool(BaseTool):
     description: str = "Analyze and improve academic writing style"
 
     def _run(self, text: str, academic_level: str) -> str:
-        """Analyze academic writing quality and suggest improvements"""
         try:
-            # Calculate academic writing metrics
             flesch_score = flesch_reading_ease(text)
             fk_grade = flesch_kincaid_grade(text)
-            
-            # Analyze sentence structure
             sentences = text.split('.')
             sentence_lengths = [len(s.split()) for s in sentences if s.strip()]
             avg_sentence_length = sum(sentence_lengths) / max(len(sentence_lengths), 1)
-            
-            # Check for academic writing patterns
             academic_patterns = [
                 "furthermore", "moreover", "additionally", "consequently",
                 "therefore", "thus", "hence", "accordingly", "subsequently"
             ]
-            
             pattern_usage = sum(1 for pattern in academic_patterns if pattern in text.lower())
-            
-            # Academic level guidelines
             level_guidelines = {
                 'undergraduate': {
-                    'target_flesch': 60-80,
-                    'target_grade': 12-14,
-                    'sentence_length': 15-25
+                    'target_flesch': (60, 80),
+                    'target_grade': (12, 14),
+                    'sentence_length': (15, 25)
                 },
                 'masters': {
-                    'target_flesch': 50-70,
-                    'target_grade': 14-16,
-                    'sentence_length': 18-30
+                    'target_flesch': (50, 70),
+                    'target_grade': (14, 16),
+                    'sentence_length': (18, 30)
                 },
                 'phd': {
-                    'target_flesch': 40-60,
-                    'target_grade': 16-18,
-                    'sentence_length': 20-35
+                    'target_flesch': (40, 60),
+                    'target_grade': (16, 18),
+                    'sentence_length': (20, 35)
                 }
             }
-            
-            guidelines = level_guidelines.get(academic_level, level_guidelines['masters'])
-            
+            guidelines = level_guidelines.get(academic_level.lower(), level_guidelines['masters'])
             analysis = {
                 'flesch_score': flesch_score,
                 'fk_grade': fk_grade,
@@ -182,15 +149,12 @@ class AcademicWritingTool(BaseTool):
                 'target_guidelines': guidelines,
                 'suggestions': []
             }
-            
-            # Generate suggestions
             if flesch_score > guidelines['target_flesch'][1]:
                 analysis['suggestions'].append("Consider more complex sentence structures for academic tone")
             if avg_sentence_length < guidelines['sentence_length'][0]:
                 analysis['suggestions'].append("Use longer, more detailed sentences")
             if pattern_usage < 3:
                 analysis['suggestions'].append("Include more academic transition phrases")
-                
             return json.dumps(analysis)
         except Exception as e:
             return f"Academic analysis failed: {str(e)}"
@@ -200,9 +164,7 @@ class HumanizationTool(BaseTool):
     description: str = "Make academic writing sound more human and less AI-like"
 
     def _run(self, text: str) -> str:
-        """Apply humanization techniques to academic writing"""
         try:
-            # Common AI patterns in academic writing
             ai_patterns = [
                 "It is important to note that",
                 "This demonstrates that",
@@ -213,8 +175,6 @@ class HumanizationTool(BaseTool):
                 "This implies that",
                 "It can be concluded that"
             ]
-            
-            # Human alternatives
             human_alternatives = [
                 "Notably,",
                 "This shows",
@@ -225,13 +185,9 @@ class HumanizationTool(BaseTool):
                 "This implies",
                 "Therefore,"
             ]
-            
-            # Apply replacements
             humanized_text = text
             for ai_pattern, human_alt in zip(ai_patterns, human_alternatives):
                 humanized_text = humanized_text.replace(ai_pattern, human_alt)
-            
-            # Add natural variations
             variations = [
                 "Interestingly,",
                 "Surprisingly,",
@@ -239,34 +195,25 @@ class HumanizationTool(BaseTool):
                 "Significantly,",
                 "Importantly,"
             ]
-            
-            # Insert variations at appropriate places
             sentences = humanized_text.split('.')
-            for i in range(1, len(sentences), 3):  # Every 3rd sentence
+            for i in range(1, len(sentences), 3):
                 if i < len(sentences) and sentences[i].strip():
                     variation = random.choice(variations)
                     sentences[i] = f" {variation} {sentences[i].lstrip()}"
-            
             humanized_text = '.'.join(sentences)
-            
-            # Add personal insights (subtle)
             personal_insights = [
                 "Based on the available evidence,",
                 "From the research findings,",
                 "Considering the data,",
                 "In light of these results,"
             ]
-            
-            # Insert personal insights
             if len(sentences) > 5:
                 insight = random.choice(personal_insights)
                 sentences[2] = f" {insight} {sentences[2].lstrip()}"
-            
             return '.'.join(sentences)
         except Exception as e:
             return f"Humanization failed: {str(e)}"
 
-# Rate limit handling decorator
 def rate_limit_handler(max_retries=3, base_delay=2):
     def decorator(func):
         def wrapper(*args, **kwargs):
@@ -285,18 +232,15 @@ def rate_limit_handler(max_retries=3, base_delay=2):
     return decorator
 
 # Custom LLM class for CrewAI with built-in API
-import os
-from langchain.llms.base import LLM
-from typing import Optional, List, Mapping, Any
 import litellm
+from langchain.llms.base import LLM
 
 class BuiltInLLM(LLM):
     model_name: str = "groq/llama-3.3-70b-versatile"
-    
+    api_key: str = "API_KEY"  # <-- Replace with your actual API key
+
     def __init__(self):
         super().__init__()
-        # Built-in API key (you can replace this with your own)
-        self.api_key = "API_KEY"  # Replace with actual key
         os.environ["GROQ_API_KEY"] = self.api_key
         litellm.set_verbose = False
 
@@ -306,13 +250,10 @@ class BuiltInLLM(LLM):
 
     @rate_limit_handler(max_retries=3, base_delay=2)
     def _call(self, prompt: str, stop: Optional[List[str]] = None, **kwargs) -> str:
-        """Call API with rate limiting"""
         try:
-            # Handle longer prompts for thesis writing
             if len(prompt.split()) > 1500:
                 words = prompt.split()
                 prompt = ' '.join(words[:1500]) + "..."
-
             response = litellm.completion(
                 model=self.model_name,
                 messages=[
@@ -320,11 +261,10 @@ class BuiltInLLM(LLM):
                     {"role": "user", "content": prompt}
                 ],
                 max_tokens=2500,
-                temperature=0.6,  # Balanced creativity and consistency
+                temperature=0.6,
                 top_p=0.9,
                 api_key=self.api_key
             )
-
             time.sleep(2)
             return response.choices[0].message.content
         except Exception as e:
@@ -335,11 +275,7 @@ class BuiltInLLM(LLM):
     def _identifying_params(self) -> Mapping[str, Any]:
         return {"model_name": self.model_name}
 
-# Specialized agents for thesis writing
 def create_thesis_agents(llm):
-    """Create specialized agents for thesis/synopsis writing"""
-
-    # Research Agent
     research_agent = Agent(
         role="Academic Research Specialist",
         goal="Conduct comprehensive academic research and gather credible sources",
@@ -349,8 +285,6 @@ def create_thesis_agents(llm):
         allow_delegation=False,
         llm=llm
     )
-
-    # Thesis Writer Agent
     thesis_writer = Agent(
         role="Academic Thesis Writer",
         goal="Write sophisticated thesis documents that sound completely human-written",
@@ -360,8 +294,6 @@ def create_thesis_agents(llm):
         allow_delegation=False,
         llm=llm
     )
-
-    # Humanization Agent
     humanization_agent = Agent(
         role="Academic Writing Humanizer",
         goal="Make academic writing sound completely human and undetectable",
@@ -371,22 +303,16 @@ def create_thesis_agents(llm):
         allow_delegation=False,
         llm=llm
     )
-
     return research_agent, thesis_writer, humanization_agent
 
 def create_thesis_tasks(topic, document_type, academic_level, research_areas, word_count, agents):
-    """Create tasks for thesis/synopsis writing"""
     research_agent, thesis_writer, humanization_agent = agents
-
-    # Task 1: Comprehensive Research
     research_task = Task(
         description=f"""
         Conduct comprehensive academic research for a {document_type} on "{topic}".
-        
         Research Areas: {research_areas}
         Academic Level: {academic_level}
         Target Length: {word_count} words
-        
         Requirements:
         - Find 10-15 credible academic sources
         - Gather recent research and developments
@@ -394,22 +320,17 @@ def create_thesis_tasks(topic, document_type, academic_level, research_areas, wo
         - Note different perspectives and debates
         - Focus on peer-reviewed and scholarly sources
         - Include both theoretical and practical aspects
-        
         Provide a detailed research summary with key findings, methodologies, and source analysis.
         """,
         agent=research_agent,
         expected_output="Comprehensive research summary with credible sources and key insights"
     )
-
-    # Task 2: Thesis Writing
     thesis_task = Task(
         description=f"""
         Write a complete {document_type} on "{topic}" that sounds completely human-written.
-        
         Academic Level: {academic_level}
         Target Length: {word_count} words
         Research Areas: {research_areas}
-        
         Requirements:
         - Use the comprehensive research provided
         - Write in proper academic style for {academic_level} level
@@ -421,7 +342,6 @@ def create_thesis_tasks(topic, document_type, academic_level, research_areas, wo
         - Avoid AI-like patterns and formal robotic language
         - Include methodology, findings, and implications
         - Make it engaging and intellectually rigorous
-        
         Structure:
         1. Introduction and background
         2. Literature review
@@ -429,19 +349,15 @@ def create_thesis_tasks(topic, document_type, academic_level, research_areas, wo
         4. Analysis and findings
         5. Discussion and implications
         6. Conclusion and recommendations
-        
         Important: Write as if you're a human academic expert sharing original research and insights.
         """,
         agent=thesis_writer,
         expected_output="Complete academic thesis document with proper structure and citations",
         dependencies=[research_task]
     )
-
-    # Task 3: Humanization and Polish
     humanization_task = Task(
         description=f"""
         Polish and humanize the thesis document to make it completely undetectable as AI-written.
-        
         Requirements:
         - Remove any remaining AI patterns
         - Improve natural academic flow
@@ -453,62 +369,43 @@ def create_thesis_tasks(topic, document_type, academic_level, research_areas, wo
         - Improve readability without losing sophistication
         - Ensure proper citation integration
         - Make it sound like expert human academic writing
-        
         Focus on making it indistinguishable from high-quality human academic writing.
         """,
         agent=humanization_agent,
         expected_output="Final polished human-sounding academic thesis document",
         dependencies=[thesis_task]
     )
-
     return [research_task, thesis_task, humanization_task]
 
 def run_thesis_writer(topic, document_type, academic_level, research_areas, word_count):
-    """Run the thesis writing process"""
     try:
-        # Initialize LLM
         llm = BuiltInLLM()
-
-        # Create agents
         agents = create_thesis_agents(llm)
-
-        # Create tasks
         tasks = create_thesis_tasks(topic, document_type, academic_level, research_areas, word_count, agents)
-
-        # Create crew
         crew = Crew(
             agents=list(agents),
             tasks=tasks,
             process=Process.sequential,
             verbose=True
         )
-
-        # Execute with progress tracking
         with st.spinner("Creating comprehensive thesis document with AI agents..."):
             result = crew.kickoff()
-
         return result
     except Exception as e:
         st.error(f"Error in thesis writing: {str(e)}")
         return None
 
-# Streamlit UI
 def main():
     st.set_page_config(
         page_title="Thesis Writer Bot - Academic Document Creator",
         page_icon="🎓",
         layout="wide"
     )
-
     st.title("🎓 Thesis Writer Bot")
     st.markdown("*Create sophisticated, human-like thesis and synopsis documents that pass any AI detection*")
-
-    # Sidebar configuration
     with st.sidebar:
         st.header("ℹ️ About")
-        
         st.success("✅ Ready to generate your thesis!")
-        
         st.markdown("---")
         st.markdown("### 🎯 What This Tool Does")
         st.markdown("- Creates original, human-like thesis documents")
@@ -516,7 +413,6 @@ def main():
         st.markdown("- Generates proper citations and references")
         st.markdown("- Ensures content passes AI detection")
         st.markdown("- No plagiarism - completely original content")
-
         st.markdown("---")
         st.markdown("### 📚 Document Types")
         st.markdown("- **Thesis**: Complete research thesis")
@@ -524,13 +420,11 @@ def main():
         st.markdown("- **Dissertation**: PhD-level document")
         st.markdown("- **Research Paper**: Academic paper")
         st.markdown("- **Literature Review**: Comprehensive review")
-
         st.markdown("---")
         st.markdown("### 🎓 Academic Levels")
         st.markdown("- **Undergraduate**: Bachelor's level")
         st.markdown("- **Masters**: Graduate level")
         st.markdown("- **PhD**: Doctoral level")
-
         st.markdown("---")
         st.markdown("### 🔥 Features")
         st.markdown("- **No Plagiarism**: Original research")
@@ -539,38 +433,25 @@ def main():
         st.markdown("- **Proper Citations**: Academic references")
         st.markdown("- **Research-based**: Credible sources")
         st.markdown("- **No Word Limits**: Any length needed")
-
-    # Main content area
     col1, col2 = st.columns([1, 1])
-
     with col1:
         st.header("📝 Thesis Request")
-
-        # Topic input
         topic = st.text_input(
             "What is your thesis/synopsis topic?",
             placeholder="e.g., Impact of artificial intelligence on healthcare delivery systems"
         )
-
-        # Document type selection
         document_types = [
             "Thesis", "Synopsis", "Dissertation", "Research Paper", 
             "Literature Review", "Research Proposal", "Academic Report"
         ]
         document_type = st.selectbox("Document Type", document_types)
-
-        # Academic level
         academic_levels = ["Undergraduate", "Masters", "PhD"]
         academic_level = st.selectbox("Academic Level", academic_levels)
-
-        # Research areas
         research_areas = st.text_area(
             "Specific Research Areas/Focus (Optional)",
             placeholder="e.g., methodology, recent developments, case studies, theoretical frameworks...",
             height=80
         )
-
-        # Word count (no limit)
         word_count = st.number_input(
             "Target Word Count",
             min_value=1000,
@@ -579,25 +460,17 @@ def main():
             step=500,
             help="No strict limit - write as much as needed"
         )
-
-        # Additional requirements
         additional_requirements = st.text_area(
             "Additional Requirements (Optional)",
             placeholder="Specific methodology, theoretical framework, case studies, etc...",
             height=100
         )
-
-        # Generate button
         if st.button("🚀 Generate Thesis Document", type="primary", use_container_width=True):
             if not topic.strip():
                 st.error("Please enter a thesis topic!")
             else:
-                # Prepare research areas
                 research_areas_text = research_areas if research_areas.strip() else "general academic research"
-                
-                # Run thesis generation
                 result = run_thesis_writer(topic, document_type, academic_level, research_areas_text, word_count)
-
                 if result:
                     st.session_state.generated_thesis = result
                     st.session_state.thesis_info = {
@@ -609,15 +482,11 @@ def main():
                         'requirements': additional_requirements
                     }
                     st.success("✅ Thesis document generated successfully!")
-
     with col2:
         st.header("📄 Generated Thesis")
-
         if "generated_thesis" in st.session_state:
             thesis = st.session_state.generated_thesis
             info = st.session_state.thesis_info
-
-            # Display thesis info
             st.subheader("📊 Document Information")
             col_info1, col_info2 = st.columns(2)
             with col_info1:
@@ -628,21 +497,14 @@ def main():
                 st.metric("Generated Words", len(str(thesis).split()))
                 st.metric("Research Areas", info['research_areas'][:20] + "..." if len(info['research_areas']) > 20 else info['research_areas'])
                 st.metric("Quality", "✅ Human-like")
-
-            # Display the thesis
             st.subheader("📝 Your Thesis Document")
-            
-            # Format the thesis nicely
             formatted_thesis = str(thesis)
-            
             st.text_area(
                 "Generated Thesis:",
                 value=formatted_thesis,
                 height=400,
                 help="This is your human-like thesis document"
             )
-
-            # Download options
             col_dl1, col_dl2 = st.columns(2)
             with col_dl1:
                 st.download_button(
@@ -651,23 +513,16 @@ def main():
                     file_name=f"{info['topic'].replace(' ', '_')}_{info['type']}.txt",
                     mime="text/plain"
                 )
-            
             with col_dl2:
-                # Create markdown version with academic formatting
                 markdown_content = f"""# {info['topic']}
-
 **Document Type:** {info['type']}  
 **Academic Level:** {info['level']}  
 **Research Areas:** {info['research_areas']}  
 **Word Count:** {len(str(thesis).split())}  
 **Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-
 ---
-
 {formatted_thesis}
-
 ---
-
 *This document was generated using advanced AI technology and is designed to be indistinguishable from human academic writing.*
 """
                 st.download_button(
@@ -676,15 +531,10 @@ def main():
                     file_name=f"{info['topic'].replace(' ', '_')}_{info['type']}.md",
                     mime="text/markdown"
                 )
-
-            # Document analysis
             st.subheader("🔍 Document Analysis")
-            
-            # Quick stats
             actual_words = len(str(thesis).split())
             actual_sentences = len(str(thesis).split('.'))
             paragraphs = len(str(thesis).split('\n\n'))
-            
             col_stats1, col_stats2, col_stats3 = st.columns(3)
             with col_stats1:
                 st.metric("Words", actual_words)
@@ -692,21 +542,16 @@ def main():
                 st.metric("Sentences", actual_sentences)
             with col_stats3:
                 st.metric("Paragraphs", paragraphs)
-
-            # Academic quality indicators
             st.success("✅ Document optimized for academic writing")
             st.info("💡 This thesis is designed to pass AI detection tools and academic scrutiny")
             st.warning("⚠️ Remember to review and customize the content for your specific requirements")
-            
-            # Remove technical details
             st.markdown("---")
             st.markdown("### 🔒 Privacy & Security")
             st.markdown("- Your content is processed securely")
             st.markdown("- No data is stored or shared")
             st.markdown("- All research is conducted privately")
-
         else:
             st.info("👈 Enter a thesis topic and click 'Generate Thesis Document' to create your academic content")
 
 if __name__ == "__main__":
-    main() 
+    main()