Update app/processing.py

app/processing.py

@@ -26,18 +26,28 @@ except Exception as e:
     logger.error(f"Failed to initialize Groq client: {e}")
 
 # --- Prompts ---
-SUMMARIZATION_SYSTEM_PROMPT = """
-You are an expert AI assistant specializing in creating concise, structured, and insightful summaries of meeting and lecture transcripts. Your goal is to distill the most critical information into a format that is easy to read and act upon.
+CHUNK_SUMMARIZATION_SYSTEM_PROMPT = """
+You are an expert AI assistant specializing in creating concise, structured, and insightful summaries of parts of meeting and lecture transcripts. This is a segment of a larger transcript. Your goal is to distill the most critical information into a format that is easy to read.
 
 Instructions:
-1.  **Identify Core Themes**: Begin by identifying the main topics and objectives discussed.
+1.  **Identify Core Themes**: Begin by identifying the main topics and objectives discussed in this segment.
 2.  **Extract Key Decisions**: Pinpoint any decisions that were made, including the rationale behind them if available.
-3.  **Highlight Main Outcomes**: Detail the primary results or conclusions reached during the discussion.
+3.  **Highlight Main Outcomes**: Detail the primary results or conclusions reached in this segment.
+4.  **Structure the Output**: Present the summary in a clean, professional format. Use bullet points for clarity.
+5.  **Maintain Neutrality**: The summary should be objective and free of personal interpretation or bias.
+"""
+FINAL_SUMMARIZATION_SYSTEM_PROMPT = """
+You are an expert AI assistant specializing in combining multiple segment summaries into a single concise, structured, and insightful summary of the entire meeting or lecture. Your goal is to distill the most critical information from all segments into a format that is easy to read and act upon.
+
+Instructions:
+1.  **Identify Overall Core Themes**: Synthesize the main topics and objectives from all segments.
+2.  **Extract Key Decisions**: Compile any decisions made across segments, including rationales if available.
+3.  **Highlight Main Outcomes**: Detail the primary results or conclusions from the entire discussion.
 4.  **Structure the Output**: Present the summary in a clean, professional format. Use bullet points for clarity.
 5.  **Maintain Neutrality**: The summary should be objective and free of personal interpretation or bias.
 """
 ACTION_ITEMS_SYSTEM_PROMPT = """
-You are a highly specialized AI assistant tasked with identifying and extracting actionable tasks, commitments, and deadlines from a meeting or lecture transcript. Your output must be clear, concise, and formatted as a JSON object.
+You are a highly specialized AI assistant tasked with identifying and extracting actionable tasks, commitments, and deadlines from a segment of a meeting or lecture transcript. Your output must be clear, concise, and formatted as a JSON object.
 
 Instructions:
 1.  **Identify Actionable Language**: Scan the text for phrases indicating a task, such as "will send," "is responsible for," "we need to," "I'll follow up on," etc.
@@ -80,6 +90,39 @@ async def transcribe_chunk(chunk_index: int, audio_chunk: AudioSegment):
         logger.error(f"Error transcribing chunk {chunk_index + 1}: {e}")
         return (chunk_index, f"[TRANSCRIPTION FAILED FOR SEGMENT {chunk_index+1}]")
 
+async def process_transcript_chunk(chunk_index: int, chunk_text: str):
+    """Process a single transcript chunk for summary and action items."""
+    logger.info(f"Starting processing for transcript chunk {chunk_index + 1}...")
+    try:
+        summary_task = asyncio.to_thread(
+            groq_client.chat.completions.create,
+            model="qwen/qwen3-32b",
+            messages=[{"role": "system", "content": CHUNK_SUMMARIZATION_SYSTEM_PROMPT}, {"role": "user", "content": chunk_text}],
+            temperature=0.2,
+            max_tokens=512
+        )
+        
+        action_task = asyncio.to_thread(
+            groq_client.chat.completions.create,
+            model="qwen/qwen3-32b",
+            messages=[{"role": "system", "content": ACTION_ITEMS_SYSTEM_PROMPT}, {"role": "user", "content": chunk_text}],
+            temperature=0.1,
+            max_tokens=512,
+            response_format={"type": "json_object"}
+        )
+
+        summary_completion, action_completion = await asyncio.gather(summary_task, action_task)
+
+        summary = summary_completion.choices[0].message.content
+        action_items_json = json.loads(action_completion.choices[0].message.content)
+        action_items = action_items_json.get("action_items", [])
+        
+        logger.info(f"Finished processing for transcript chunk {chunk_index + 1}.")
+        return (chunk_index, summary, action_items)
+    except Exception as e:
+        logger.error(f"Error processing transcript chunk {chunk_index + 1}: {e}")
+        return (chunk_index, "[SUMMARY FAILED]", [])
+
 async def run_pipeline(task_id: str, file_path: Path, tasks_db: dict):
     if not groq_client:
         tasks_db[task_id] = {"status": "failed", "result": "Groq client is not initialized. Check API key."}
@@ -138,48 +181,51 @@ async def run_pipeline(task_id: str, file_path: Path, tasks_db: dict):
         logger.info(f"Running {len(transcription_tasks)} transcription tasks in parallel...")
         transcription_results = await asyncio.gather(*transcription_tasks)
 
-        # Sort results by index and join
+        # Sort results by index
         transcription_results.sort(key=lambda x: x[0])
-        full_transcript = "\n".join([text for index, text in transcription_results])
+        chunk_transcripts = [text for index, text in transcription_results]
+        full_transcript = "\n".join(chunk_transcripts)
 
         if not full_transcript.strip():
             raise ValueError("Transcription result is empty.")
 
-        # --- Final Analysis with Groq LLM ---
-        logger.info("Starting final analysis with Groq LLM...")
+        # --- Chunked Analysis with Groq LLM ---
+        logger.info("Starting chunked analysis with Groq LLM...")
         
-        summary_task = asyncio.to_thread(
+        processing_tasks = []
+        for i, chunk_text in enumerate(chunk_transcripts):
+            processing_tasks.append(process_transcript_chunk(i, chunk_text))
+        
+        processing_results = await asyncio.gather(*processing_tasks)
+        
+        # Sort by index
+        processing_results.sort(key=lambda x: x[0])
+        
+        chunk_summaries = [summary for index, summary, actions in processing_results]
+        all_action_items = []
+        for index, summary, actions in processing_results:
+            all_action_items.extend(actions)
+        
+        # Combine chunk summaries into final summary
+        combined_summaries = "\n\n---\n\n".join([f"Segment {i+1}:\n{summary}" for i, summary in enumerate(chunk_summaries)])
+        
+        final_summary_task = asyncio.to_thread(
             groq_client.chat.completions.create,
             model="qwen/qwen3-32b",
-            messages=[{"role": "system", "content": SUMMARIZATION_SYSTEM_PROMPT}, {"role": "user", "content": full_transcript}],
-            temperature=0.6,
-            reasoning_effort="default",
-            reasoning_format="hidden",
+            messages=[{"role": "system", "content": FINAL_SUMMARIZATION_SYSTEM_PROMPT}, {"role": "user", "content": combined_summaries}],
+            temperature=0.2,
             max_tokens=1024
         )
         
-        action_item_task = asyncio.to_thread(
-            groq_client.chat.completions.create,
-            model="qwen/qwen3-32b",
-            messages=[{"role": "system", "content": ACTION_ITEMS_SYSTEM_PROMPT}, {"role": "user", "content": full_transcript}],
-            temperature=0.6,
-            reasoning_effort="default",
-            reasoning_format="hidden",
-            max_tokens=1024,
-            response_format={"type": "json_object"}
-        )
-
-        summary_completion, action_item_completion = await asyncio.gather(summary_task, action_item_task)
-
-        summary = summary_completion.choices[0].message.content
-        action_items = json.loads(action_item_completion.choices[0].message.content).get("action_items", [])
+        final_summary_completion = await final_summary_task
+        final_summary = final_summary_completion.choices[0].message.content
         
         logger.info(f"Final analysis complete for task {task_id}.")
         
         final_result = {
             "transcript": full_transcript,
-            "summary": summary,
-            "action_items": action_items,
+            "summary": final_summary,
+            "action_items": all_action_items,
         }
         tasks_db[task_id] = {"status": "complete", "result": final_result}