Create app.py

app.py

@@ -0,0 +1,712 @@
+import streamlit as st
+import os
+import requests
+import hashlib
+from typing import List, Dict, Any
+from datetime import datetime
+import json
+import re
+from urllib.parse import quote
+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
+import nltk
+from textstat import flesch_reading_ease, flesch_kincaid_grade
+from bs4 import BeautifulSoup
+import concurrent.futures
+from duckduckgo_search import DDGS
+
+# Download NLTK data
+try:
+    nltk.download('punkt', quiet=True)
+    nltk.download('stopwords', quiet=True)
+    nltk.download('wordnet', quiet=True)
+except:
+    pass
+
+# Custom Tools for Academic Research and Writing
+class AcademicResearchTool(BaseTool):
+    name: str = "academic_research"
+    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",
+                f"{topic} recent developments",
+                f"{topic} methodology",
+                f"{topic} literature review"
+            ]
+            
+            all_research = []
+            
+            with DDGS() as ddgs:
+                for query in search_queries:
+                    try:
+                        results = list(ddgs.text(query, max_results=6))
+                        for result in results:
+                            all_research.append({
+                                'query': query,
+                                'title': result.get('title', ''),
+                                'content': result.get('body', ''),
+                                'url': result.get('href', ''),
+                                'relevance_score': self._calculate_relevance(result.get('body', ''), topic)
+                            })
+                        time.sleep(0.5)  # Rate limiting
+                    except Exception as e:
+                        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
+        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):
+    name: str = "citation_generator"
+    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
+                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,
+                    'url': url,
+                    'domain': domain,
+                    'apa_citation': f"{domain}. ({datetime.now().year}). {title}. Retrieved from {url}",
+                    '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)}"
+
+class AcademicWritingTool(BaseTool):
+    name: str = "academic_writing"
+    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
+                },
+                'masters': {
+                    '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
+                }
+            }
+            
+            guidelines = level_guidelines.get(academic_level, level_guidelines['masters'])
+            
+            analysis = {
+                'flesch_score': flesch_score,
+                'fk_grade': fk_grade,
+                'avg_sentence_length': avg_sentence_length,
+                'academic_patterns_used': pattern_usage,
+                '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)}"
+
+class HumanizationTool(BaseTool):
+    name: str = "humanization_tool"
+    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",
+                "This indicates that",
+                "As previously mentioned",
+                "It should be mentioned that",
+                "This suggests that",
+                "This implies that",
+                "It can be concluded that"
+            ]
+            
+            # Human alternatives
+            human_alternatives = [
+                "Notably,",
+                "This shows",
+                "This reveals",
+                "As noted earlier",
+                "It's worth noting",
+                "This suggests",
+                "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,",
+                "Remarkably,",
+                "Significantly,",
+                "Importantly,"
+            ]
+            
+            # Insert variations at appropriate places
+            sentences = humanized_text.split('.')
+            for i in range(1, len(sentences), 3):  # Every 3rd sentence
+                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):
+            for attempt in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    if "rate_limit" in str(e).lower() and attempt < max_retries - 1:
+                        delay = base_delay * (2 ** attempt) + random.uniform(0, 1)
+                        st.warning(f"Rate limit hit. Retrying in {delay:.1f} seconds... (Attempt {attempt + 1}/{max_retries})")
+                        time.sleep(delay)
+                    else:
+                        raise e
+            return None
+        return wrapper
+    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
+
+class BuiltInLLM(LLM):
+    model_name: str = "groq/llama-3.3-70b-versatile"
+    
+    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
+
+    @property
+    def _llm_type(self) -> str:
+        return "groq"
+
+    @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=[
+                    {"role": "system", "content": "You are an expert academic writer who creates sophisticated, well-researched thesis documents that sound completely human-written. You avoid AI patterns and create authentic academic content with proper citations and natural flow."},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=2500,
+                temperature=0.6,  # Balanced creativity and consistency
+                top_p=0.9,
+                api_key=self.api_key
+            )
+
+            time.sleep(2)
+            return response.choices[0].message.content
+        except Exception as e:
+            st.error(f"Error in processing: {str(e)}")
+            return f"Error: {str(e)}"
+
+    @property
+    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",
+        backstory="You are a PhD-level researcher with expertise in finding and analyzing academic sources. You understand how to identify credible information and synthesize research findings.",
+        tools=[AcademicResearchTool()],
+        verbose=True,
+        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",
+        backstory="You are an experienced academic writer who specializes in creating thesis documents. You know how to write in a way that sounds natural and scholarly, avoiding AI patterns while maintaining academic rigor.",
+        tools=[AcademicWritingTool(), CitationGeneratorTool()],
+        verbose=True,
+        allow_delegation=False,
+        llm=llm
+    )
+
+    # Humanization Agent
+    humanization_agent = Agent(
+        role="Academic Writing Humanizer",
+        goal="Make academic writing sound completely human and undetectable",
+        backstory="You are an expert editor who specializes in making academic content sound natural and human-written. You know how to eliminate AI patterns and create authentic scholarly writing.",
+        tools=[HumanizationTool()],
+        verbose=True,
+        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
+        - Identify key theories and methodologies
+        - 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
+        - Include proper citations and references
+        - Create logical structure with introduction, body, and conclusion
+        - Use varied sentence structures and academic vocabulary
+        - Include critical analysis and original insights
+        - Maintain scholarly tone while sounding natural
+        - 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
+        3. Methodology
+        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
+        - Add authentic human writing touches
+        - Ensure varied sentence structures
+        - Make transitions feel natural and scholarly
+        - Add subtle personal insights and critical thinking
+        - Maintain academic rigor while sounding human
+        - 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")
+        st.markdown("- Conducts comprehensive academic research")
+        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")
+        st.markdown("- **Synopsis**: Research proposal/synopsis")
+        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")
+        st.markdown("- **Human-like**: Natural academic writing")
+        st.markdown("- **AI Undetectable**: Passes detection")
+        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,
+            max_value=50000,
+            value=5000,
+            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 = {
+                        'topic': topic,
+                        'type': document_type,
+                        'level': academic_level,
+                        'research_areas': research_areas_text,
+                        'word_count': word_count,
+                        '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:
+                st.metric("Topic", info['topic'])
+                st.metric("Type", info['type'])
+                st.metric("Level", info['level'])
+            with col_info2:
+                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(
+                    label="📥 Download as TXT",
+                    data=formatted_thesis,
+                    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(
+                    label="📥 Download as MD",
+                    data=markdown_content,
+                    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)
+            with col_stats2:
+                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()