comment extra functions and optimized prompt

utils/optimizer.py

@@ -39,8 +39,8 @@ class ContentOptimizer:
             "    \"structuredness\": 7.0,\n"
             "    \"answerability\": 9.0\n"
             "  }},\n"
-            "  \"keywords\": [\"example\", \"installation\", \"setup\"],\n"
-            "  \"optimized_text\": \"...\"\n"
+            "  \"keywords\": [\"example\", \"installation\", \"setup\"],\n,"
+            "  \"optimized_text\": \"...\"\n,"
             "}}\n"
             "```"
         )
@@ -78,27 +78,8 @@ class ContentOptimizer:
         )
 
         # Competitive content analysis prompt
-        self.competitive_analysis_prompt = (
-            "Compare this content against best practices for AI search optimization. Identify gaps and opportunities.\n"
-            "Original Content: {content}\n"
-            "Analyze against these AI search factors:\n"
-            "- Entity recognition and linking\n"
-            "- Question coverage completeness\n"
-            "- Factual statement clarity\n"
-            "- Conversational flow\n"
-            "- Semantic relationship mapping\n\n"
-            "Provide competitive analysis in JSON format with specific recommendations:\n"
-            "{{\n"
-            "  \"competitive_analysis\": {{\n"
-            "    \"entity_gaps\": [\"gap1\", \"gap2\"],\n"
-            "    \"question_coverage\": \"summary of coverage\",\n"
-            "    \"factual_clarity\": \"assessment\",\n"
-            "    \"conversational_flow\": \"assessment\",\n"
-            "    \"semantic_relationships\": [\"relationship1\", \"relationship2\"]\n"
-            "  }},\n"
-            "  \"recommendations\": [\"recommendation 1\", \"recommendation 2\"]\n"
-            "}}\n"
-        )
+       self.competitive_analysis_prompt = ("Analyze the following content for AI search optimization gaps in entities, questions, clarity, flow, and semantic links. Return JSON with gaps and actionable recommendations.\nContent: {content}")
+
     
         # Dedicated prompt for rewriting/optimizing content
         self.optimization_rewrite_prompt = (
@@ -113,7 +94,7 @@ class ContentOptimizer:
         )
 
     def optimize_content(self, content: str, analyze_only: bool = False, 
-                        include_keywords: bool = True, optimization_type: str = "standard") -> Dict[str, Any]:
+                        include_keywords: bool = True, optimization_type: str = "seo") -> Dict[str, Any]:
         """
             Main content optimization function
             Args:
@@ -148,14 +129,15 @@ class ContentOptimizer:
                     '"optimized_text": "..."',
                     '"optimization_suggestions": ["suggestion 1", "suggestion 2"]'
                 )
-                if not include_keywords:
-                    prompt_text = prompt_text.replace(
-                        '"keywords": ["example", "installation", "setup"],',
-                        ''
-                    )
-            else:
-                # Use dedicated rewrite prompt for optimization
-                prompt_text = self.optimization_rewrite_prompt
+            # else:
+            #     # Use dedicated rewrite prompt for optimization
+            #     prompt_text = self.optimization_rewrite_prompt
+                
+            if not include_keywords:
+                prompt_text = prompt_text.replace(
+                    '"keywords": ["example", "installation", "setup"],',
+                    ''
+                )
 
             prompt_template = ChatPromptTemplate.from_messages([
                 SystemMessagePromptTemplate.from_template(prompt_text),
@@ -186,8 +168,7 @@ class ContentOptimizer:
                  SystemMessagePromptTemplate.from_template(self.seo_style_prompt),
                  HumanMessagePromptTemplate.from_template(f"Optimize this content for AI search engines:\n\n{content[:6000]}")
             ])
-                # ("system", self.seo_style_prompt),
-                # ("user", f"Optimize this content for AI search engines:\n\n{content[:6000]}")
+               
             
             chain = prompt_template | self.llm
             result = chain.invoke({})
@@ -235,99 +216,99 @@ class ContentOptimizer:
         except Exception as e:
             return {'error': f"Competitive optimization failed: {str(e)}"}
     
-    def batch_optimize_content(self, content_list: List[str], optimization_type: str = "standard") -> List[Dict[str, Any]]:
-        """
-        Optimize multiple pieces of content in batch
+    # def batch_optimize_content(self, content_list: List[str], optimization_type: str = "standard") -> List[Dict[str, Any]]:
+    #     """
+    #     Optimize multiple pieces of content in batch
         
-        Args:
-            content_list (List[str]): List of content pieces to optimize
-            optimization_type (str): Type of optimization to apply
-            
-        Returns:
-            List[Dict]: List of optimization results
-        """
-        results = []
+    #     Args:
+    #         content_list (List[str]): List of content pieces to optimize
+    #         optimization_type (str): Type of optimization to apply
+            
+    #     Returns:
+    #         List[Dict]: List of optimization results
+    #     """
+    #     results = []
         
-        for i, content in enumerate(content_list):
-            try:
-                result = self.optimize_content(
-                    content, 
-                    optimization_type=optimization_type
-                )
-                result['batch_index'] = i
-                results.append(result)
+    #     for i, content in enumerate(content_list):
+    #         try:
+    #             result = self.optimize_content(
+    #                 content, 
+    #                 optimization_type=optimization_type
+    #             )
+    #             result['batch_index'] = i
+    #             results.append(result)
                 
-            except Exception as e:
-                results.append({
-                    'batch_index': i,
-                    'error': f"Batch optimization failed: {str(e)}"
-                })
+    #         except Exception as e:
+    #             results.append({
+    #                 'batch_index': i,
+    #                 'error': f"Batch optimization failed: {str(e)}"
+    #             })
         
-        return results
+    #     return results
     
-    def generate_content_variations(self, content: str, num_variations: int = 3) -> List[Dict[str, Any]]:
-        """
-        Generate multiple optimized variations of the same content
+    # def generate_content_variations(self, content: str, num_variations: int = 3) -> List[Dict[str, Any]]:
+    #     """
+    #     Generate multiple optimized variations of the same content
         
-        Args:
-            content (str): Original content
-            num_variations (int): Number of variations to generate
-            
-        Returns:
-            List[Dict]: List of content variations with analysis
-        """
-        variations = []
+    #     Args:
+    #         content (str): Original content
+    #         num_variations (int): Number of variations to generate
+            
+    #     Returns:
+    #         List[Dict]: List of content variations with analysis
+    #     """
+    #     variations = []
         
-        variation_prompts = [
-            "Create a more conversational version optimized for AI chat responses",
-            "Create a more authoritative version optimized for citations",
-            "Create a more structured version optimized for question-answering"
-        ]
+    #     variation_prompts = [
+    #         "Create a more conversational version optimized for AI chat responses",
+    #         "Create a more authoritative version optimized for citations",
+    #         "Create a more structured version optimized for question-answering"
+    #     ]
         
-        for i in range(min(num_variations, len(variation_prompts))):
-            try:
-                custom_prompt = f"""You are optimizing content for AI systems. {variation_prompts[i]}.
+    #     for i in range(min(num_variations, len(variation_prompts))):
+    #         try:
+    #             custom_prompt = f"""You are optimizing content for AI systems. {variation_prompts[i]}.
 
-                                    Original content: {content[:4000]}
+    #                                 Original content: {content[:4000]}
 
-                                    Provide the optimized variation in JSON format:
-                                    ```json
-                                    {{
-                                    "variation_type": "conversational/authoritative/structured",
-                                    "optimized_content": "the rewritten content...",
-                                    "key_changes": ["change 1", "change 2"],
-                                    "target_use_case": "description of ideal use case"
-                                    }}
-                                    ```
-                                """
+    #                                 Provide the optimized variation in JSON format:
+    #                                 ```json
+    #                                 {{
+    #                                 "variation_type": "conversational/authoritative/structured",
+    #                                 "optimized_content": "the rewritten content...",
+    #                                 "key_changes": ["change 1", "change 2"],
+    #                                 "target_use_case": "description of ideal use case"
+    #                                 }}
+    #                                 ```
+    #                             """
                 
-                prompt_template = ChatPromptTemplate.from_messages([
-                    SystemMessagePromptTemplate.from_template(custom_prompt),
-                    HumanMessagePromptTemplate.from_template("Generate the variation.")
-                ])
-                    # ("system", custom_prompt),
-                    # ("user", "Generate the variation.")
+    #             prompt_template = ChatPromptTemplate.from_messages([
+    #                 SystemMessagePromptTemplate.from_template(custom_prompt),
+    #                 HumanMessagePromptTemplate.from_template("Generate the variation.")
+    #             ])
+    #                 # ("system", custom_prompt),
+    #                 # ("user", "Generate the variation.")
                 
-                chain = prompt_template | self.llm
-                result = chain.invoke({})
+    #             chain = prompt_template | self.llm
+    #             result = chain.invoke({})
                 
-                result_content = result.content if hasattr(result, 'content') else str(result)
-                parsed_result = self._parse_optimization_result(result_content)
+    #             result_content = result.content if hasattr(result, 'content') else str(result)
+    #             parsed_result = self._parse_optimization_result(result_content)
                 
-                parsed_result.update({
-                    'variation_index': i,
-                    'variation_prompt': variation_prompts[i]
-                })
+    #             parsed_result.update({
+    #                 'variation_index': i,
+    #                 'variation_prompt': variation_prompts[i]
+    #             })
                 
-                variations.append(parsed_result)
+    #             variations.append(parsed_result)
                 
-            except Exception as e:
-                variations.append({
-                    'variation_index': i,
-                    'error': f"Variation generation failed: {str(e)}"
-                })
+    #         except Exception as e:
+    #             variations.append({
+    #                 'variation_index': i,
+    #                 'error': f"Variation generation failed: {str(e)}"
+    #             })
         
-        return variations
+    #     return variations
     
     def analyze_content_readability(self, content: str) -> Dict[str, Any]:
         """
@@ -388,56 +369,56 @@ class ContentOptimizer:
         except Exception as e:
             return {'error': f"Readability analysis failed: {str(e)}"}
     
-    def extract_key_entities(self, content: str) -> Dict[str, Any]:
-        """
-        Extract key entities and topics for optimization
+    # def extract_key_entities(self, content: str) -> Dict[str, Any]:
+    #     """
+    #     Extract key entities and topics for optimization
         
-        Args:
-            content (str): Content to analyze
-            
-        Returns:
-            Dict: Extracted entities and topics
-        """
-        try:
-            entity_prompt = """Extract key entities, topics, and concepts from this content for AI optimization.
+    #     Args:
+    #         content (str): Content to analyze
+            
+    #     Returns:
+    #         Dict: Extracted entities and topics
+    #     """
+    #     try:
+    #         entity_prompt = """Extract key entities, topics, and concepts from this content for AI optimization.
 
-                                Content: {content}
+    #                             Content: {content}
 
-                                Identify:
-                                1. Named entities (people, places, organizations)
-                                2. Key concepts and topics
-                                3. Technical terms and jargon
-                                4. Potential semantic keywords
-                                5. Question-answer opportunities
+    #                             Identify:
+    #                             1. Named entities (people, places, organizations)
+    #                             2. Key concepts and topics
+    #                             3. Technical terms and jargon
+    #                             4. Potential semantic keywords
+    #                             5. Question-answer opportunities
 
-                                Format as JSON:
-                                ```json
-                                {{
-                                "named_entities": ["entity1", "entity2"],
-                                "key_topics": ["topic1", "topic2"],
-                                "technical_terms": ["term1", "term2"],
-                                "semantic_keywords": ["keyword1", "keyword2"],
-                                "question_opportunities": ["What is...", "How does..."],
-                                "entity_relationships": ["relationship descriptions"]
-                                }}
-                                ```
-                            """
-            
-            prompt_template = ChatPromptTemplate.from_messages([
-                SystemMessagePromptTemplate.from_template(entity_prompt.format(content=content[:5000])),
-                HumanMessagePromptTemplate.from_template("Extract the entities and topics.")
-            ])
-                # ("system", entity_prompt.format(content=content[:5000])),
-                # ("user", "Extract the entities and topics.")
-            
-            chain = prompt_template | self.llm
-            result = chain.invoke({})
-            
-            result_content = result.content if hasattr(result, 'content') else str(result)
-            return self._parse_optimization_result(result_content)
-            
-        except Exception as e:
-            return {'error': f"Entity extraction failed: {str(e)}"}
+    #                             Format as JSON:
+    #                             ```json
+    #                             {{
+    #                             "named_entities": ["entity1", "entity2"],
+    #                             "key_topics": ["topic1", "topic2"],
+    #                             "technical_terms": ["term1", "term2"],
+    #                             "semantic_keywords": ["keyword1", "keyword2"],
+    #                             "question_opportunities": ["What is...", "How does..."],
+    #                             "entity_relationships": ["relationship descriptions"]
+    #                             }}
+    #                             ```
+    #                         """
+            
+    #         prompt_template = ChatPromptTemplate.from_messages([
+    #             SystemMessagePromptTemplate.from_template(entity_prompt.format(content=content[:5000])),
+    #             HumanMessagePromptTemplate.from_template("Extract the entities and topics.")
+    #         ])
+    #             # ("system", entity_prompt.format(content=content[:5000])),
+    #             # ("user", "Extract the entities and topics.")
+            
+    #         chain = prompt_template | self.llm
+    #         result = chain.invoke({})
+            
+    #         result_content = result.content if hasattr(result, 'content') else str(result)
+    #         return self._parse_optimization_result(result_content)
+            
+    #     except Exception as e:
+    #         return {'error': f"Entity extraction failed: {str(e)}"}
     
     def optimize_for_voice_search(self, content: str) -> Dict[str, Any]:
         """
@@ -450,32 +431,8 @@ class ContentOptimizer:
             Dict: Voice search optimization results
         """
         try:
-            voice_prompt = """Optimize this content for voice search and conversational AI systems.
-
-                                Focus on:
-                                1. Natural language patterns
-                                2. Question-based structure
-                                3. Conversational tone
-                                4. Clear, direct answers
-                                5. Featured snippet optimization
+           self.voice_prompt = ("Optimize the following content for voice search and conversational AI by improving natural language flow, question-based structure, tone, and featured snippet potential. Return JSON with improved content, Q&A pairs, snippet candidates, and a conversational score.\nContent: {content}")
 
-                                Original content: {content}
-
-                                Provide optimization in JSON:
-                                ```json
-                                {{
-                                "voice_optimized_content": "conversational version...",
-                                "question_answer_pairs": [
-                                  {{"question": "What is...", "answer": "Direct answer..."}},
-                                  {{"question": "How does...", "answer": "Step by step..."}}
-                                ],
-                                "featured_snippet_candidates": ["snippet 1", "snippet 2"],
-                                "natural_language_improvements": ["improvement 1", "improvement 2"],
-                                "conversational_score": 8.5
-                                }}
-                                ```
-                            """
-            
             prompt_template = ChatPromptTemplate.from_messages([
                 SystemMessagePromptTemplate.from_template(voice_prompt.format(content=content[:4000])),
                 HumanMessagePromptTemplate.from_template("Optimize for voice search.")