midterm-submission

server/agents.py

@@ -15,7 +15,7 @@ import numpy as np
 from langchain.schema import SystemMessage, HumanMessage, AIMessage
 from langchain.output_parsers import PydanticOutputParser
 from pydantic import BaseModel, Field
-from workflow import save_transcript
+from utils import save_transcript
 
 # Configure logging
 logging.basicConfig(

server/utils.py

@@ -0,0 +1,52 @@
+import os
+import json
+import uuid
+import logging
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+# Create transcripts directory if it doesn't exist
+TRANSCRIPTS_DIR = os.path.join(os.path.dirname(__file__), "transcripts")
+os.makedirs(TRANSCRIPTS_DIR, exist_ok=True)
+TRANSCRIPTS_FILE = os.path.join(TRANSCRIPTS_DIR, "podcasts.json")
+
+def save_transcript(podcast_script: str, user_query: str) -> None:
+    """Save podcast transcript to JSON file."""
+    # Create new transcript entry
+    transcript = {
+        "id": str(uuid.uuid4()),
+        "podcastScript": podcast_script,
+        "topic": user_query
+    }
+    
+    try:
+        # Load existing transcripts
+        if os.path.exists(TRANSCRIPTS_FILE):
+            try:
+                with open(TRANSCRIPTS_FILE, 'r') as f:
+                    transcripts = json.load(f)
+                    if not isinstance(transcripts, list):
+                        transcripts = []
+            except json.JSONDecodeError:
+                logger.warning("Error reading transcripts file, initializing empty list")
+                transcripts = []
+        else:
+            transcripts = []
+        
+        # Append new transcript
+        transcripts.append(transcript)
+        
+        # Save updated transcripts
+        with open(TRANSCRIPTS_FILE, 'w') as f:
+            json.dump(transcripts, f, indent=2)
+            logger.info("Successfully saved transcript")
+            
+    except Exception as e:
+        logger.error(f"Error saving transcript: {str(e)}")
+        # Create directory if it doesn't exist
+        os.makedirs(os.path.dirname(TRANSCRIPTS_FILE), exist_ok=True)
+        # Try to save just this transcript
+        with open(TRANSCRIPTS_FILE, 'w') as f:
+            json.dump([transcript], f, indent=2)
+            logger.info("Saved single transcript after error") 

server/workflow.py

@@ -1,10 +1,13 @@
 from typing import Dict, Any, List, Annotated, TypedDict, Union, Optional
 from langgraph.graph import Graph, END
 from agents import create_agents
+from utils import save_transcript
 import os
 from dotenv import load_dotenv
-import json
-import uuid
+import logging
+
+# Configure logging
+logger = logging.getLogger(__name__)
 
 # Load environment variables
 load_dotenv()
@@ -73,11 +76,11 @@ def create_workflow(tavily_api_key: str):
     # Define the extractor node function
     async def run_extractor(state: AgentState) -> Dict[str, Any]:
         query = state["messages"][-1]["content"]
-        print(f"Extractor processing query: {query}")
+        logger.info(f"Extractor processing query: {query}")
         
         try:
             response = await agents["extractor"](query)
-            print(f"Extractor response: {response}")
+            logger.info(f"Extractor response: {response}")
             
             # Update state
             state["extractor_data"] = response
@@ -88,7 +91,7 @@ def create_workflow(tavily_api_key: str):
                 "skeptic": {"content": "Not started"},
                 "believer": {"content": "Not started"}
             })
-            print(f"Initial supervisor analysis: {supervisor_analysis}")
+            logger.info(f"Initial supervisor analysis: {supervisor_analysis}")
             
             state["supervisor_notes"].append(supervisor_analysis["content"])
             state["supervisor_chunks"].append(supervisor_analysis.get("chunks", {}))
@@ -97,17 +100,17 @@ def create_workflow(tavily_api_key: str):
             state["current_agent"] = "debate"
             return state
         except Exception as e:
-            print(f"Error in extractor: {str(e)}")
+            logger.error(f"Error in extractor: {str(e)}")
             raise Exception(f"Error in extractor: {str(e)}")
 
     # Define the debate node function
     async def run_debate(state: AgentState) -> Dict[str, Any]:
-        print(f"Debate turn {state['debate_turns']}")
+        logger.info(f"Debate turn {state['debate_turns']}")
         
         try:
             if state["debate_turns"] == 0:
                 # First turn: both agents respond to extractor
-                print("Starting first debate turn")
+                logger.info("Starting first debate turn")
                 
                 # If we have context, use it to inform the agents' responses
                 context = state.get("context", {})
@@ -126,7 +129,7 @@ def create_workflow(tavily_api_key: str):
                     {"speaker": "skeptic", "content": skeptic_response["content"]},
                     {"speaker": "believer", "content": believer_response["content"]}
                 ])
-                print(f"First turn responses added: {state['debate_history'][-2:]}")
+                logger.info(f"First turn responses added: {state['debate_history'][-2:]}")
             else:
                 # Alternating responses based on agent type if specified
                 if state["agent_type"] in ["believer", "skeptic"]:
@@ -136,7 +139,7 @@ def create_workflow(tavily_api_key: str):
                     last_speaker = state["debate_history"][-1]["speaker"]
                     current_speaker = "believer" if last_speaker == "skeptic" else "skeptic"
                 
-                print(f"Processing response for {current_speaker}")
+                logger.info(f"Processing response for {current_speaker}")
                 
                 # Create context-aware input
                 context = state.get("context", {})
@@ -152,7 +155,7 @@ def create_workflow(tavily_api_key: str):
                     "speaker": current_speaker,
                     "content": response["content"]
                 })
-                print(f"Added response: {state['debate_history'][-1]}")
+                logger.info(f"Added response: {state['debate_history'][-1]}")
             
             # Add supervisor note and chunks
             supervisor_analysis = await agents["supervisor"]({
@@ -160,26 +163,26 @@ def create_workflow(tavily_api_key: str):
                 "skeptic": {"content": state["debate_history"][-1]["content"]},
                 "believer": {"content": state["debate_history"][-2]["content"] if len(state["debate_history"]) > 1 else "Not started"}
             })
-            print(f"Supervisor analysis: {supervisor_analysis}")
+            logger.info(f"Supervisor analysis: {supervisor_analysis}")
             
             state["supervisor_notes"].append(supervisor_analysis["content"])
             state["supervisor_chunks"].append(supervisor_analysis.get("chunks", {}))
             
             state["debate_turns"] += 1
-            print(f"Debate turn {state['debate_turns']} completed")
+            logger.info(f"Debate turn {state['debate_turns']} completed")
             
             # End the workflow after 2 debate turns
             if state["debate_turns"] >= 2:
                 state["current_agent"] = "podcast"
-                print("Moving to podcast production")
+                logger.info("Moving to podcast production")
             
             return state
         except Exception as e:
-            print(f"Error in debate: {str(e)}")
+            logger.error(f"Error in debate: {str(e)}")
             raise Exception(f"Error in debate: {str(e)}")
 
     async def run_podcast_producer(state: AgentState) -> Dict[str, Any]:
-        print("Starting podcast production")
+        logger.info("Starting podcast production")
         
         try:
             # Create podcast from debate
@@ -190,7 +193,7 @@ def create_workflow(tavily_api_key: str):
                 state["supervisor_chunks"],
                 {}  # Empty quadrant analysis since we removed storage manager
             )
-            print(f"Podcast production result: {podcast_result}")
+            logger.info(f"Podcast production result: {podcast_result}")
             
             # Save transcript to JSON file
             save_transcript(
@@ -205,7 +208,7 @@ def create_workflow(tavily_api_key: str):
             state["current_agent"] = END
             return state
         except Exception as e:
-            print(f"Error in podcast production: {str(e)}")
+            logger.error(f"Error in podcast production: {str(e)}")
             raise Exception(f"Error in podcast production: {str(e)}")
 
     # Add nodes to the graph