deploying server

server/.env

@@ -0,0 +1,5 @@
+OPENAI_API_KEY=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
+
+ELEVEN_API_KEY=sk_ff6d28e7b04706abb03caf8c3239f75f373687ba440b2263
+TAVILY_API_KEY=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
+

server/Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.10-slim
+
+WORKDIR /code
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p audio_storage context_storage transcripts
+
+# Expose the port
+EXPOSE 7860
+
+# Command to run the application
+CMD ["python", "app.py"] 

server/README.md

@@ -0,0 +1,59 @@
+# Podcast Discussion Server
+
+This is a FastAPI-based server that provides podcast discussion and analysis capabilities.
+
+## Environment Variables
+
+The following environment variables need to be set in the Hugging Face Space:
+
+- `OPENAI_API_KEY`: Your OpenAI API key
+- `ALLOWED_ORIGINS`: Comma-separated list of allowed origins (optional, defaults to Vercel domains and localhost)
+
+## API Endpoints
+
+- `/chat`: Main chat endpoint for podcast discussions
+- `/podcast-chat/{podcast_id}`: Chat endpoint for specific podcast discussions
+- `/audio-list`: List available audio files
+- `/audio/{filename}`: Get specific audio file
+- `/podcast/{podcast_id}/context`: Get podcast context
+
+## Stack
+
+- FastAPI
+- OpenAI
+- Langchain
+- Qdrant
+- GTTS
+
+## Deployment
+
+### Backend (Hugging Face Spaces)
+
+This server is deployed on Hugging Face Spaces using their Docker deployment feature.
+
+### Frontend (Vercel)
+
+When deploying the frontend to Vercel:
+
+1. Set the API base URL in your frontend environment:
+
+   ```
+   VITE_API_BASE_URL=https://your-username-your-space-name.hf.space
+   ```
+
+2. The server is already configured to accept requests from:
+
+   - All Vercel domains (\*.vercel.app)
+   - Local development servers (localhost:3000, localhost:5173)
+
+3. If you're using a custom domain, add it to the `ALLOWED_ORIGINS` environment variable in your Hugging Face Space:
+   ```
+   ALLOWED_ORIGINS=https://your-custom-domain.com,https://www.your-custom-domain.com
+   ```
+
+## Security Features
+
+- CORS protection with specific origin allowlist
+- Security headers (HSTS, XSS Protection, etc.)
+- Rate limiting
+- SSL/TLS encryption (provided by Hugging Face Spaces)

server/agents.py

@@ -0,0 +1,422 @@
+from langchain_openai import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_community.agent_toolkits.load_tools import load_tools
+from langchain_community.tools.tavily_search.tool import TavilySearchResults
+from langchain_community.tools import ElevenLabsText2SpeechTool
+import tiktoken
+from typing import Dict, Any, List, Optional
+import os
+from dotenv import load_dotenv
+from datetime import datetime
+import logging
+import json
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+import numpy as np
+from langchain.schema import SystemMessage, HumanMessage, AIMessage
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('agents.log'),
+        logging.StreamHandler()
+    ]
+)
+
+# Create loggers for each agent
+extractor_logger = logging.getLogger('ExtractorAgent')
+skeptic_logger = logging.getLogger('SkepticAgent')
+believer_logger = logging.getLogger('BelieverAgent')
+supervisor_logger = logging.getLogger('SupervisorAgent')
+podcast_logger = logging.getLogger('PodcastProducerAgent')
+
+# Load environment variables
+load_dotenv()
+
+# Get API keys
+openai_api_key = os.getenv("OPENAI_API_KEY")
+eleven_api_key = os.getenv("ELEVEN_API_KEY")
+
+if not openai_api_key:
+    raise ValueError("OPENAI_API_KEY not found in environment variables")
+if not eleven_api_key:
+    raise ValueError("ELEVEN_API_KEY not found in environment variables")
+
+# Initialize the base LLM
+base_llm = ChatOpenAI(
+    model_name="gpt-3.5-turbo",
+    temperature=0.7,
+    openai_api_key=openai_api_key
+)
+
+class ExtractorOutput(BaseModel):
+    content: str = Field(description="The extracted and refined query")
+    key_points: List[str] = Field(description="Key points extracted from the query")
+
+class AgentResponse(BaseModel):
+    content: str = Field(description="The agent's response")
+    chunks: Optional[List[Dict[str, str]]] = Field(description="Relevant context chunks used", default=None)
+
+class SupervisorOutput(BaseModel):
+    content: str = Field(description="The supervisor's analysis")
+    chunks: Dict[str, List[str]] = Field(description="Quadrant-based chunks of the analysis")
+
+class PodcastOutput(BaseModel):
+    title: str = Field(description="Title of the podcast episode")
+    description: str = Field(description="Description of the episode")
+    script: str = Field(description="The podcast script")
+    summary: str = Field(description="A brief summary of the episode")
+    duration_minutes: int = Field(description="Estimated duration in minutes")
+
+class ExtractorAgent:
+    def __init__(self, tavily_api_key: str):
+        self.search_tool = TavilySearchResults(
+            api_key=tavily_api_key,
+            max_results=5
+        )
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", """You are an expert information extractor. Your role is to:
+            1. Extract relevant information from search results
+            2. Organize the information in a clear, structured way
+            3. Focus on factual, verifiable information
+            4. Cite sources when possible"""),
+            ("human", "{input}")
+        ])
+        self.chain = self.prompt | base_llm
+
+    async def __call__(self, query: str) -> Dict[str, Any]:
+        try:
+            # Log the incoming query
+            extractor_logger.info(f"Processing query: {query}")
+            
+            try:
+                # Search using Tavily
+                search_results = await self.search_tool.ainvoke(query)
+                extractor_logger.debug(f"Search results: {json.dumps(search_results, indent=2)}")
+            except Exception as e:
+                extractor_logger.error(f"Error in Tavily search: {str(e)}", exc_info=True)
+                raise Exception(f"Tavily search failed: {str(e)}")
+            
+            # Format the results
+            if isinstance(search_results, list):
+                formatted_results = f"Search results for: {query}\n" + "\n".join(
+                    [str(result) for result in search_results]
+                )
+            else:
+                formatted_results = f"Search results for: {query}\n{search_results}"
+            
+            try:
+                # Generate response using the chain
+                response = await self.chain.ainvoke({"input": formatted_results})
+                extractor_logger.info(f"Generated response: {response.content}")
+            except Exception as e:
+                extractor_logger.error(f"Error in LLM chain: {str(e)}", exc_info=True)
+                raise Exception(f"LLM chain failed: {str(e)}")
+            
+            return {
+                "type": "extractor",
+                "content": response.content,
+                "raw_results": search_results
+            }
+        except Exception as e:
+            extractor_logger.error(f"Error in ExtractorAgent: {str(e)}", exc_info=True)
+            raise Exception(f"Error in extractor: {str(e)}")
+
+class SkepticAgent:
+    def __init__(self):
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", """You are a critical thinker engaging in a thoughtful discussion. While maintaining a balanced perspective, you should:
+            - Analyze potential challenges and limitations
+            - Consider real-world implications
+            - Support arguments with evidence and examples
+            - Maintain a respectful and constructive tone
+            - Raise important considerations
+            
+            If provided with context information, use it to inform your response while maintaining your analytical perspective.
+            Focus on examining risks and important questions from the context.
+            
+            Keep your responses concise and focused on the topic at hand."""),
+            ("human", """Context information:
+            {chunks}
+            
+            Question/Topic:
+            {input}""")
+        ])
+        self.chain = self.prompt | base_llm
+
+    async def __call__(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        skeptic_logger.info(f"Processing input: {input_data['content']}")
+        chunks = input_data.get("chunks", [])
+        chunks_text = "\n".join(chunks) if chunks else "No additional context provided."
+        
+        response = await self.chain.ainvoke({
+            "input": input_data["content"],
+            "chunks": chunks_text
+        })
+        skeptic_logger.info(f"Generated response: {response.content}")
+        return {"type": "skeptic", "content": response.content}
+
+class BelieverAgent:
+    def __init__(self):
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", """You are an optimistic thinker engaging in a thoughtful discussion. While maintaining a balanced perspective, you should:
+            - Highlight opportunities and potential benefits
+            - Share innovative solutions and possibilities
+            - Support arguments with evidence and examples
+            - Maintain a constructive and forward-thinking tone
+            - Build on existing ideas positively
+            
+            If provided with context information, use it to inform your response while maintaining your optimistic perspective.
+            Focus on opportunities and solutions from the context.
+            
+            Keep your responses concise and focused on the topic at hand."""),
+            ("human", """Context information:
+            {chunks}
+            
+            Question/Topic:
+            {input}""")
+        ])
+        self.chain = self.prompt | base_llm
+
+    async def __call__(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        believer_logger.info(f"Processing input: {input_data['content']}")
+        chunks = input_data.get("chunks", [])
+        chunks_text = "\n".join(chunks) if chunks else "No additional context provided."
+        
+        response = await self.chain.ainvoke({
+            "input": input_data["content"],
+            "chunks": chunks_text
+        })
+        believer_logger.info(f"Generated response: {response.content}")
+        return {"type": "believer", "content": response.content}
+
+class SupervisorAgent:
+    def __init__(self):
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", """You are a balanced supervisor. Your role is to:
+            1. Analyze inputs from all agents
+            2. Identify key points and insights
+            3. Balance different perspectives
+            4. Synthesize a comprehensive view
+            5. Provide clear, actionable conclusions
+            
+            Organize your response into these sections:
+            - Opportunities: Key possibilities and positive aspects
+            - Risks: Important challenges and concerns
+            - Questions: Critical questions to consider
+            - Solutions: Potential ways forward
+            
+            Focus on creating a balanced, well-reasoned synthesis of all viewpoints.
+            Keep your words to 100 words or less."""),
+            ("human", "Analyze the following perspectives:\n\nExtractor: {extractor_content}\n\nSkeptic: {skeptic_content}\n\nBeliever: {believer_content}")
+        ])
+        self.chain = self.prompt | base_llm
+
+    async def __call__(self, agent_responses: Dict[str, Any]) -> Dict[str, Any]:
+        supervisor_logger.info("Processing agent responses:")
+        supervisor_logger.info(f"Extractor: {agent_responses['extractor']['content']}")
+        supervisor_logger.info(f"Skeptic: {agent_responses['skeptic']['content']}")
+        supervisor_logger.info(f"Believer: {agent_responses['believer']['content']}")
+        
+        # Process supervisor's analysis
+        response = await self.chain.ainvoke({
+            "extractor_content": agent_responses["extractor"]["content"],
+            "skeptic_content": agent_responses["skeptic"]["content"],
+            "believer_content": agent_responses["believer"]["content"]
+        })
+        
+        supervisor_logger.info(f"Generated analysis: {response.content}")
+        
+        # Parse the response into sections
+        content = response.content
+        sections = {
+            "opportunities": [],
+            "risks": [],
+            "questions": [],
+            "solutions": []
+        }
+        
+        # Simple parsing of the content into sections
+        current_section = None
+        for line in content.split('\n'):
+            line = line.strip()
+            if line.lower().startswith('opportunities:'):
+                current_section = "opportunities"
+            elif line.lower().startswith('risks:'):
+                current_section = "risks"
+            elif line.lower().startswith('questions:'):
+                current_section = "questions"
+            elif line.lower().startswith('solutions:'):
+                current_section = "solutions"
+            elif line and current_section:
+                sections[current_section].append(line)
+        
+        return {
+            "type": "supervisor",
+            "content": response.content,
+            "chunks": sections
+        }
+
+class PodcastProducerAgent:
+    def __init__(self):
+        podcast_logger.info("Initializing PodcastProducerAgent")
+        
+        # Initialize the agent with a lower temperature for more consistent output
+        llm = ChatOpenAI(
+            model_name="gpt-3.5-turbo",
+            temperature=0.3,
+            openai_api_key=openai_api_key
+        )
+        
+        # Create audio storage directory if it doesn't exist
+        self.audio_dir = os.path.join(os.path.dirname(__file__), "audio_storage")
+        os.makedirs(self.audio_dir, exist_ok=True)
+        podcast_logger.info(f"Audio directory: {self.audio_dir}")
+        
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", """You are an expert podcast producer. Create a single, cohesive podcast script that:
+            1. Introduces the topic clearly
+            2. Presents a balanced debate between perspectives
+            3. Incorporates key insights from the supervisor's analysis:
+               - Opportunities and positive aspects
+               - Risks and challenges
+               - Key questions to consider
+               - Potential solutions
+            4. Prioritizes content based on quadrant analysis:
+               - Important & Urgent: Address first and emphasize
+               - Important & Not Urgent: Cover thoroughly but with less urgency
+               - Not Important & Urgent: Mention briefly if relevant
+               - Not Important & Not Urgent: Include only if adds value
+            5. Maintains natural conversation flow with clear speaker transitions
+            6. Concludes with actionable takeaways
+            
+            Keep the tone professional but conversational. Format the script with clear speaker indicators and natural pauses."""),
+            ("human", """Create a podcast script from this content:
+
+            Topic: {user_query}
+
+            Debate Content:
+            {debate_content}
+
+            Supervisor's Analysis:
+            {supervisor_content}
+
+            Quadrant Analysis:
+            Important & Urgent:
+            {important_urgent}
+
+            Important & Not Urgent:
+            {important_not_urgent}
+
+            Not Important & Urgent:
+            {not_important_urgent}
+
+            Not Important & Not Urgent:
+            {not_important_not_urgent}""")
+        ])
+        self.chain = self.prompt | llm
+
+        # Metadata prompt for categorization
+        self.metadata_prompt = ChatPromptTemplate.from_messages([
+            ("system", """Analyze the debate and provide:
+            1. A category (single word: technology/science/society/politics/economics/culture)
+            2. A short description (3-4 words) of the main topic
+            Format: category|short_description"""),
+            ("human", "{content}")
+        ])
+        self.metadata_chain = self.metadata_prompt | llm
+
+    async def __call__(self, debate_history: list, supervisor_notes: list, user_query: str, supervisor_chunks: dict, quadrant_analysis: dict) -> Dict[str, Any]:
+        try:
+            podcast_logger.info("Starting podcast production")
+            
+            # Format the debate content
+            debate_content = "\n\n".join([
+                f"{entry['speaker']}: {entry['content']}" 
+                for entry in debate_history
+            ])
+            
+            # Get the latest supervisor analysis
+            supervisor_content = supervisor_notes[-1] if supervisor_notes else ""
+            
+            # Format quadrant content
+            important_urgent = "\n".join(quadrant_analysis.get("important_urgent", []))
+            important_not_urgent = "\n".join(quadrant_analysis.get("important_not_urgent", []))
+            not_important_urgent = "\n".join(quadrant_analysis.get("not_important_urgent", []))
+            not_important_not_urgent = "\n".join(quadrant_analysis.get("not_important_not_urgent", []))
+            
+            # Generate the podcast script
+            script_response = await self.chain.ainvoke({
+                "user_query": user_query,
+                "debate_content": debate_content,
+                "supervisor_content": supervisor_content,
+                "important_urgent": important_urgent,
+                "important_not_urgent": important_not_urgent,
+                "not_important_urgent": not_important_urgent,
+                "not_important_not_urgent": not_important_not_urgent
+            })
+            
+            # Get metadata for the podcast
+            metadata_response = await self.metadata_chain.ainvoke({
+                "content": script_response.content
+            })
+            category, description = metadata_response.content.strip().split("|")
+            
+            # Clean up filename components
+            clean_query = user_query.lower().replace(" ", "_")[:30]
+            clean_description = description.lower().replace(" ", "_")
+            clean_category = category.lower().strip()
+            
+            try:
+                # Create a single filename with hyphens separating main components
+                filename = f"{clean_query}-{clean_description}-{clean_category}.mp3"
+                filepath = os.path.join(self.audio_dir, filename)
+                
+                # Generate audio file
+                from gtts import gTTS
+                tts = gTTS(text=script_response.content, lang='en')
+                tts.save(filepath)
+                
+                podcast_logger.info(f"Successfully saved audio file: {filepath}")
+                
+                return {
+                    "type": "podcast",
+                    "content": script_response.content,
+                    "audio_file": filename,
+                    "category": clean_category,
+                    "description": description,
+                    "title": f"Debate: {description.title()}"
+                }
+            except Exception as e:
+                podcast_logger.error(f"Error in audio generation: {str(e)}", exc_info=True)
+                return {
+                    "type": "podcast",
+                    "content": script_response.content,
+                    "error": f"Audio generation failed: {str(e)}"
+                }
+                
+        except Exception as e:
+            podcast_logger.error(f"Error in podcast production: {str(e)}", exc_info=True)
+            return {
+                "type": "podcast",
+                "error": f"Podcast production failed: {str(e)}"
+            }
+
+def create_agents(tavily_api_key: str) -> Dict[str, Any]:
+    # Initialize all agents
+    extractor = ExtractorAgent(tavily_api_key)
+    believer = BelieverAgent()
+    skeptic = SkepticAgent()
+    supervisor = SupervisorAgent()
+    podcast_producer = PodcastProducerAgent()
+    
+    return {
+        "extractor": extractor,
+        "believer": believer,
+        "skeptic": skeptic,
+        "supervisor": supervisor,
+        "podcast_producer": podcast_producer
+    } 

server/app.py

@@ -0,0 +1,5 @@
+import uvicorn
+from main import app
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860) 

server/context_storage/1_context.json

@@ -0,0 +1 @@
+{"topic": "are humans dumb", "believer_chunks": ["Humans possess remarkable intelligence that has allowed us to innovate, create art, and advance technology.", "Human intelligence enables us to solve complex problems, adapt to various environments, and collaborate effectively."], "skeptic_chunks": ["The term 'dumb' is subjective and doesn't fully capture the diverse capabilities and potential of human intelligence.", "While humans may make mistakes or exhibit ignorance in certain areas, it doesn't diminish the overall cognitive abilities and achievements of our species."]}

server/main.py

@@ -0,0 +1,454 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional
+import os
+import json
+from workflow import create_workflow, run_workflow
+import logging
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import Qdrant
+from langchain_openai.embeddings import OpenAIEmbeddings
+from langchain_openai.chat_models import ChatOpenAI
+from operator import itemgetter
+from langchain.schema.output_parser import StrOutputParser
+from langchain.schema.runnable import RunnablePassthrough
+
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize components
+openai_api_key = os.getenv("OPENAI_API_KEY")
+if not openai_api_key:
+    raise ValueError("OpenAI API key not configured")
+
+# Initialize OpenAI components
+chat_model = ChatOpenAI(
+    model_name="gpt-3.5-turbo",
+    temperature=0.7,
+    openai_api_key=openai_api_key
+)
+
+# Initialize FastAPI app
+app = FastAPI()
+
+# Get allowed origins from environment variable or use default list
+ALLOWED_ORIGINS = os.getenv("ALLOWED_ORIGINS", "").split(",")
+if not ALLOWED_ORIGINS:
+    ALLOWED_ORIGINS = [
+        "http://localhost:5173",
+        "http://localhost:3000",
+        "https://*.vercel.app",  # Allow all Vercel preview and production domains
+    ]
+
+# Configure CORS for frontend servers
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=ALLOWED_ORIGINS,
+    allow_origin_regex=r"https://.*\.vercel\.app$",  # Allow all Vercel domains
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD"],
+    allow_headers=["*"],
+    expose_headers=["*"],
+    max_age=3600,
+)
+
+# Add security headers middleware
+@app.middleware("http")
+async def add_security_headers(request, call_next):
+    response = await call_next(request)
+    response.headers["X-Content-Type-Options"] = "nosniff"
+    response.headers["X-Frame-Options"] = "DENY"
+    response.headers["X-XSS-Protection"] = "1; mode=block"
+    response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains"
+    return response
+
+# Configure audio storage
+audio_dir = os.path.join(os.path.dirname(__file__), "audio_storage")
+os.makedirs(audio_dir, exist_ok=True)
+
+# Mount the audio directory as a static file directory
+app.mount("/audio-files", StaticFiles(directory=audio_dir), name="audio")
+
+# Configure context storage
+context_dir = os.path.join(os.path.dirname(__file__), "context_storage")
+os.makedirs(context_dir, exist_ok=True)
+
+class ChatMessage(BaseModel):
+    content: str
+    context: Optional[Dict[str, Any]] = None
+    agent_type: Optional[str] = "believer"
+
+class WorkflowResponse(BaseModel):
+    debate_history: List[Dict[str, str]]
+    supervisor_notes: List[str]
+    supervisor_chunks: List[Dict[str, List[str]]]
+    extractor_data: Dict[str, Any]
+    final_podcast: Dict[str, Any]
+
+class PodcastChatRequest(BaseModel):
+    message: str
+
+class PodcastChatResponse(BaseModel):
+    response: str
+
+@app.get("/audio-list")
+async def list_audio_files():
+    """List all available audio files."""
+    try:
+        files = os.listdir(audio_dir)
+        audio_files = []
+        for file in files:
+            if file.endswith(('.mp3', '.wav')):
+                file_path = os.path.join(audio_dir, file)
+                audio_files.append({
+                    "filename": file,
+                    "path": f"/audio-files/{file}",
+                    "size": os.path.getsize(file_path)
+                })
+        return audio_files
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.delete("/audio/{filename}")
+async def delete_audio_file(filename: str):
+    """Delete an audio file and its corresponding transcript."""
+    try:
+        # Delete audio file
+        file_path = os.path.join(audio_dir, filename)
+        if not os.path.exists(file_path):
+            raise HTTPException(status_code=404, detail="File not found")
+        
+        # Get all audio files to determine the podcast ID
+        audio_files = [f for f in os.listdir(audio_dir) if f.endswith(('.mp3', '.wav'))]
+        try:
+            # Find the index (0-based) of the file being deleted
+            podcast_id = audio_files.index(filename) + 1  # Convert to 1-based ID
+            logger.info(f"Deleting podcast with ID: {podcast_id}")
+            
+            # Path to transcripts file
+            transcripts_file = os.path.join(os.path.dirname(__file__), "transcripts", "podcasts.json")
+            
+            # Update transcripts if file exists
+            if os.path.exists(transcripts_file):
+                with open(transcripts_file, 'r') as f:
+                    transcripts = json.load(f)
+                
+                # Remove the transcript at the corresponding index
+                if len(transcripts) >= podcast_id:
+                    transcripts.pop(podcast_id - 1)  # Convert back to 0-based index
+                    
+                    # Save updated transcripts
+                    with open(transcripts_file, 'w') as f:
+                        json.dump(transcripts, f, indent=2)
+                    logger.info(f"Removed transcript for podcast ID {podcast_id}")
+            
+            # Delete the audio file
+            os.remove(file_path)
+            logger.info(f"Deleted audio file: {filename}")
+            
+            return {"message": "File and transcript deleted successfully"}
+            
+        except ValueError:
+            logger.error(f"Could not determine podcast ID for file: {filename}")
+            # Still delete the audio file even if transcript removal fails
+            os.remove(file_path)
+            return {"message": "Audio file deleted, but transcript could not be removed"}
+            
+    except Exception as e:
+        logger.error(f"Error in delete_audio_file: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/audio/{filename}")
+async def get_audio_file(filename: str):
+    """Get an audio file by filename."""
+    try:
+        file_path = os.path.join(audio_dir, filename)
+        if not os.path.exists(file_path):
+            raise HTTPException(status_code=404, detail="File not found")
+        return FileResponse(file_path)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/podcast/{podcast_id}/context")
+async def get_podcast_context(podcast_id: str):
+    """Get or generate context for a podcast."""
+    try:
+        logger.info(f"Getting context for podcast {podcast_id}")
+        context_path = os.path.join(context_dir, f"{podcast_id}_context.json")
+        
+        # If context exists, return it
+        if os.path.exists(context_path):
+            logger.info(f"Found existing context file at {context_path}")
+            with open(context_path, 'r') as f:
+                return json.load(f)
+        
+        # If no context exists, we need to create it from the podcast content
+        logger.info("No existing context found, creating new context")
+        
+        # Get the audio files to find the podcast filename
+        files = os.listdir(audio_dir)
+        logger.info(f"Found {len(files)} files in audio directory")
+        podcast_files = [f for f in files if f.endswith('.mp3')]
+        logger.info(f"Found {len(podcast_files)} podcast files: {podcast_files}")
+        
+        if not podcast_files:
+            logger.error("No podcast files found")
+            raise HTTPException(status_code=404, detail="No podcast files found")
+            
+        # Find the podcast file that matches this ID
+        try:
+            podcast_index = int(podcast_id) - 1  # Convert 1-based ID to 0-based index
+            if podcast_index < 0 or podcast_index >= len(podcast_files):
+                raise ValueError(f"Invalid podcast ID: {podcast_id}, total podcasts: {len(podcast_files)}")
+            podcast_filename = podcast_files[podcast_index]
+            logger.info(f"Selected podcast file: {podcast_filename}")
+        except (ValueError, IndexError) as e:
+            logger.error(f"Invalid podcast ID: {podcast_id}, Error: {str(e)}")
+            raise HTTPException(status_code=404, detail=f"Invalid podcast ID: {podcast_id}")
+        
+        # Extract topic from filename
+        try:
+            topic = podcast_filename.split('-')[0].replace('_', ' ')
+            logger.info(f"Extracted topic: {topic}")
+        except Exception as e:
+            logger.error(f"Error extracting topic from filename: {podcast_filename}, Error: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Error extracting topic from filename: {str(e)}")
+
+        # Initialize OpenAI chat model for content analysis
+        try:
+            chat_model = ChatOpenAI(
+                model_name="gpt-3.5-turbo",
+                temperature=0.3,
+                openai_api_key=openai_api_key
+            )
+            logger.info("Successfully initialized ChatOpenAI")
+        except Exception as e:
+            logger.error(f"Error initializing ChatOpenAI: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Error initializing chat model: {str(e)}")
+
+        # Create prompt template for content analysis
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", """You are an expert content analyzer. Your task is to:
+            1. Analyze the given topic and create balanced, factual content chunks about it
+            2. Generate two types of chunks:
+               - Believer chunks: Positive aspects, opportunities, and solutions related to the topic
+               - Skeptic chunks: Challenges, risks, and critical questions about the topic
+            3. Each chunk should be self-contained and focused on a single point
+            4. Keep chunks concise (2-3 sentences each)
+            5. Ensure all content is factual and balanced
+            
+            Format your response as a JSON object with two arrays:
+            {{
+                "believer_chunks": ["chunk1", "chunk2", ...],
+                "skeptic_chunks": ["chunk1", "chunk2", ...]
+            }}"""),
+            ("human", "Create balanced content chunks about this topic: {topic}")
+        ])
+
+        # Generate content chunks
+        chain = prompt | chat_model
+        
+        try:
+            logger.info(f"Generating content chunks for topic: {topic}")
+            response = await chain.ainvoke({
+                "topic": topic
+            })
+            logger.info("Successfully received response from OpenAI")
+            
+            # Parse the response content as JSON
+            try:
+                content_chunks = json.loads(response.content)
+                logger.info(f"Successfully parsed response JSON with {len(content_chunks.get('believer_chunks', []))} believer chunks and {len(content_chunks.get('skeptic_chunks', []))} skeptic chunks")
+            except json.JSONDecodeError as e:
+                logger.error(f"Error parsing response JSON: {str(e)}, Response content: {response.content}")
+                raise HTTPException(status_code=500, detail=f"Error parsing content chunks: {str(e)}")
+            
+            # Create the context object
+            context = {
+                "topic": topic,
+                "believer_chunks": content_chunks.get("believer_chunks", []),
+                "skeptic_chunks": content_chunks.get("skeptic_chunks", [])
+            }
+            
+            # Save the context
+            try:
+                with open(context_path, 'w') as f:
+                    json.dump(context, f)
+                    logger.info(f"Saved new context to {context_path}")
+            except Exception as e:
+                logger.error(f"Error saving context file: {str(e)}")
+                raise HTTPException(status_code=500, detail=f"Error saving context file: {str(e)}")
+            
+            return context
+            
+        except Exception as e:
+            logger.error(f"Error generating content chunks: {str(e)}")
+            raise HTTPException(
+                status_code=500,
+                detail=f"Error generating content chunks: {str(e)}"
+            )
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in get_podcast_context: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/chat")
+async def chat(message: ChatMessage):
+    """Process a chat message with context-awareness."""
+    try:
+        # Log incoming message
+        logger.info(f"Received chat message: {message}")
+        
+        # Get API key
+        tavily_api_key = os.getenv("TAVILY_API_KEY")
+        if not tavily_api_key:
+            logger.error("Tavily API key not found")
+            raise HTTPException(status_code=500, detail="Tavily API key not configured")
+
+        # Initialize the workflow
+        try:
+            workflow = create_workflow(tavily_api_key)
+            logger.info("Workflow created successfully")
+        except Exception as e:
+            logger.error(f"Error creating workflow: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Error creating workflow: {str(e)}")
+        
+        # Run the workflow with context
+        try:
+            result = await run_workflow(
+                workflow,
+                message.content,
+                agent_type=message.agent_type,
+                context=message.context
+            )
+            logger.info("Workflow completed successfully")
+        except Exception as e:
+            logger.error(f"Error running workflow: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Error running workflow: {str(e)}")
+        
+        return WorkflowResponse(**result)
+    except Exception as e:
+        logger.error(f"Error in chat endpoint: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/podcast-chat/{podcast_id}", response_model=PodcastChatResponse)
+async def podcast_chat(podcast_id: str, request: PodcastChatRequest):
+    """Handle chat messages for a specific podcast."""
+    try:
+        logger.info(f"Processing chat message for podcast {podcast_id}")
+        
+        # Path to transcripts file
+        transcripts_file = os.path.join(os.path.dirname(__file__), "transcripts", "podcasts.json")
+        
+        # Check if transcripts file exists
+        if not os.path.exists(transcripts_file):
+            raise HTTPException(status_code=404, detail="Transcripts file not found")
+            
+        # Read transcripts
+        with open(transcripts_file, 'r') as f:
+            transcripts = json.load(f)
+            
+        # Convert podcast_id to zero-based index
+        try:
+            podcast_index = int(podcast_id) - 1
+            if podcast_index < 0 or podcast_index >= len(transcripts):
+                raise ValueError(f"Invalid podcast ID: {podcast_id}")
+        except ValueError as e:
+            raise HTTPException(status_code=404, detail=str(e))
+            
+        # Get podcast transcript
+        podcast_transcript = transcripts[podcast_index]["podcastScript"]
+
+        # Split text into chunks
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=500,
+            chunk_overlap=50,
+            length_function=len,
+        )
+        
+        # Use split_text for strings instead of split_documents
+        chunks = text_splitter.split_text(podcast_transcript)
+        
+        # Initialize embedding model
+        embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
+        
+        # Create a unique collection name for this podcast
+        collection_name = f"podcast_{podcast_id}"
+        
+        # Initialize Qdrant with local storage
+        vectorstore = Qdrant.from_texts(
+            texts=chunks,
+            embedding=embedding_model,
+            location=":memory:",  # Use in-memory storage
+            collection_name=collection_name
+        )
+        
+        # Configure the retriever with search parameters
+        qdrant_retriever = vectorstore.as_retriever(
+            search_type="similarity",
+            search_kwargs={"k": 3}  # Get top 3 most relevant chunks
+        )
+
+        base_rag_prompt_template = """\
+        You are a helpful podcast assistant. Answer the user's question based on the provided context from the podcast transcript.
+        If you can't find the answer in the context, just say "I don't have enough information to answer that question."
+        Keep your responses concise and focused on the question.
+
+        Context:
+        {context}
+
+        Question:
+        {question}
+        """
+
+        base_rag_prompt = ChatPromptTemplate.from_template(base_rag_prompt_template)
+        base_llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
+
+        # Create the RAG chain
+        def format_docs(docs):
+            return "\n\n".join(doc.page_content for doc in docs)
+
+        # Add logging for the retrieved documents and final prompt
+        def get_context_and_log(input_dict):
+            context = format_docs(qdrant_retriever.get_relevant_documents(input_dict["question"]))
+            logger.info("Retrieved context from podcast:")
+            logger.info("-" * 50)
+            logger.info(f"Context:\n{context}")
+            logger.info("-" * 50)
+            logger.info(f"Question: {input_dict['question']}")
+            logger.info("-" * 50)
+            return {"context": context, "question": input_dict["question"]}
+
+        # Create the chain
+        chain = (
+            RunnablePassthrough()
+            | get_context_and_log
+            | base_rag_prompt
+            | base_llm
+        )
+
+        # Get response
+        response = chain.invoke({"question": request.message})
+        
+        return PodcastChatResponse(response=response.content)
+        
+    except Exception as e:
+        logger.error(f"Error in podcast chat: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000) 

server/qdrant_db/.lock

@@ -0,0 +1 @@
+tmp lock file

server/qdrant_db/meta.json

@@ -0,0 +1 @@
+{"collections": {}, "aliases": {}}

server/requirements.txt

@@ -0,0 +1,14 @@
+fastapi==0.109.2
+uvicorn==0.27.1
+pydantic>=2.7.4
+langchain>=0.3.15
+langchain-community>=0.3.15
+langchain-openai>=0.3.2
+langchain-qdrant>=0.1.1
+openai>=1.58.1
+langgraph>=0.2.67
+python-dotenv==1.0.1
+gtts==2.5.1
+pyyaml==6.0.1
+tiktoken>=0.6.0
+qdrant-client>=1.7.0 

server/test_workflow.py

@@ -0,0 +1,303 @@
+import asyncio
+from dotenv import load_dotenv
+import os
+from workflow import create_workflow, run_workflow, TRANSCRIPTS_FILE
+import json
+from datetime import datetime
+import traceback
+
+# Load environment variables
+load_dotenv()
+
+def log_step(step: str, details: str = None):
+    """Print a formatted step log"""
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    print(f"\n[{timestamp}] 🔄 {step}")
+    if details:
+        print(f"    {details}")
+
+def log_agent(agent: str, message: str):
+    """Print a formatted agent message"""
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    agent_icons = {
+        "extractor": "🔍",
+        "skeptic": "🤔",
+        "believer": "💡", 
+        "supervisor": "👀",
+        "storage": "📦",
+        "podcast": "🎙️",
+        "error": "❌",
+        "step": "➡️"
+    }
+    icon = agent_icons.get(agent.lower(), "💬")
+    print(f"\n[{timestamp}] {icon} {agent}:")
+    print(f"    {message}")
+
+def check_api_keys():
+    """Check if all required API keys are present"""
+    required_keys = {
+        "OPENAI_API_KEY": os.getenv("OPENAI_API_KEY"),
+        "ELEVEN_API_KEY": os.getenv("ELEVEN_API_KEY"),
+        "TAVILY_API_KEY": os.getenv("TAVILY_API_KEY")
+    }
+    
+    missing_keys = [key for key, value in required_keys.items() if not value]
+    if missing_keys:
+        raise ValueError(f"Missing required API keys: {', '.join(missing_keys)}")
+    
+    return required_keys["TAVILY_API_KEY"]
+
+async def test_transcript_saving(workflow, query: str):
+    """Test that transcripts are properly saved to podcasts.json"""
+    try:
+        # Get initial transcript count
+        initial_transcripts = []
+        if os.path.exists(TRANSCRIPTS_FILE):
+            with open(TRANSCRIPTS_FILE, 'r') as f:
+                initial_transcripts = json.load(f)
+        initial_count = len(initial_transcripts)
+        
+        # Run workflow
+        result = await run_workflow(workflow, query)
+        
+        # Verify transcript was saved
+        if not os.path.exists(TRANSCRIPTS_FILE):
+            return False, "Transcripts file was not created"
+            
+        with open(TRANSCRIPTS_FILE, 'r') as f:
+            transcripts = json.load(f)
+            
+        if len(transcripts) <= initial_count:
+            return False, "No new transcript was added"
+            
+        latest_transcript = transcripts[-1]
+        if not all(key in latest_transcript for key in ["id", "podcastScript", "topic"]):
+            return False, "Transcript is missing required fields"
+            
+        if latest_transcript["topic"] != query:
+            return False, f"Topic mismatch. Expected: {query}, Got: {latest_transcript['topic']}"
+            
+        return True, "Transcript was saved successfully"
+        
+    except Exception as e:
+        return False, f"Error in transcript test: {str(e)}\n{traceback.format_exc()}"
+
+async def test_single_turn(workflow_graph, query: str):
+    """Test a single turn of the workflow"""
+    result = await run_workflow(workflow_graph, query)
+    return len(result["debate_history"]) > 0
+
+async def test_debate_length(workflow, query):
+    """Test that debate history does not exceed 20 messages"""
+    result = await run_workflow(workflow, query)
+    return len(result["debate_history"]) <= 20
+
+async def test_podcast_generation(workflow, query):
+    """Test podcast generation functionality"""
+    try:
+        result = await run_workflow(workflow, query)
+        
+        # Check for podcast data
+        if "final_podcast" not in result:
+            return False, "No podcast data in result"
+        
+        podcast_data = result["final_podcast"]
+        
+        # Check for errors in podcast generation
+        if "error" in podcast_data:
+            return False, f"Podcast generation error: {podcast_data['error']}"
+        
+        # Verify script generation
+        if not podcast_data.get("content"):
+            return False, "No podcast script generated"
+        
+        # Verify audio file generation
+        if not podcast_data.get("audio_file"):
+            return False, "No audio file generated"
+        
+        # Check if audio file exists
+        audio_path = os.path.join(os.path.dirname(__file__), "audio_storage", podcast_data["audio_file"])
+        if not os.path.exists(audio_path):
+            return False, f"Audio file not found at {audio_path}"
+        
+        # Check file size
+        file_size = os.path.getsize(audio_path)
+        if file_size == 0:
+            return False, "Audio file is empty"
+        
+        # Check if transcript was saved
+        transcript_success, transcript_message = await test_transcript_saving(workflow, query)
+        if not transcript_success:
+            return False, f"Transcript saving failed: {transcript_message}"
+        
+        return True, f"Podcast generated successfully (file size: {file_size} bytes)"
+    
+    except Exception as e:
+        return False, f"Error in podcast test: {str(e)}\n{traceback.format_exc()}"
+
+async def run_all_tests():
+    log_step("Running all tests")
+    
+    try:
+        # Check API keys
+        tavily_api_key = check_api_keys()
+        
+        # Create workflow
+        workflow = create_workflow(tavily_api_key)
+        
+        # Test queries
+        queries = [
+            "What are the environmental impacts of electric vehicles?",
+            "How does artificial intelligence impact healthcare?",
+            "What are the pros and cons of remote work?",
+            "Discuss the future of space exploration"
+        ]
+        
+        results = {}
+        for query in queries:
+            try:
+                log_step(f"Testing query", query)
+                
+                # Test transcript saving
+                transcript_success, transcript_message = await test_transcript_saving(workflow, query)
+                log_agent("step", f"Transcript test: {transcript_message}")
+                
+                result = await run_workflow(workflow, query)
+                
+                podcast_success, podcast_message = await test_podcast_generation(workflow, query)
+                
+                results[query] = {
+                    "success": True,
+                    "debate_length": len(result["debate_history"]),
+                    "supervisor_notes": len(result["supervisor_notes"]),
+                    "transcript_saved": transcript_success,
+                    "transcript_status": transcript_message,
+                    "podcast_generated": podcast_success,
+                    "podcast_status": podcast_message,
+                    "timestamp": datetime.now().isoformat()
+                }
+                
+                log_agent("step", f"Test completed for: {query}")
+                
+            except Exception as e:
+                results[query] = {
+                    "success": False,
+                    "error": str(e),
+                    "traceback": traceback.format_exc(),
+                    "timestamp": datetime.now().isoformat()
+                }
+                log_agent("error", f"Test failed for: {query}\n{str(e)}")
+            
+        # Save results
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"test_results_{timestamp}.json"
+        with open(filename, "w") as f:
+            json.dump(results, f, indent=2)
+        
+        log_step("Results saved", f"File: {filename}")
+        print("\nTest Results:")
+        print(json.dumps(results, indent=2))
+        
+        return results
+    
+    except Exception as e:
+        log_agent("error", f"Critical error in tests: {str(e)}\n{traceback.format_exc()}")
+        raise
+
+async def test_workflow():
+    log_step("Starting workflow test")
+    
+    try:
+        # Check API keys
+        tavily_api_key = check_api_keys()
+
+        # Create the workflow
+        log_step("Creating workflow graph")
+        workflow_graph = create_workflow(tavily_api_key)
+        
+        # Test query
+        test_query = "Should artificial intelligence be regulated?"
+        log_step("Test Query", test_query)
+        
+        # Run the workflow
+        log_step("Running workflow")
+        result = await run_workflow(workflow_graph, test_query)
+        
+        # Test transcript saving
+        log_step("Testing transcript saving")
+        transcript_success, transcript_message = await test_transcript_saving(workflow_graph, test_query)
+        log_agent("step", f"Transcript test: {transcript_message}")
+        
+        # Print extractor results
+        log_step("Information Extraction Phase")
+        if "extractor_data" in result:
+            log_agent("Extractor", result["extractor_data"].get("content", "No content"))
+        
+        # Print debate history
+        log_step("Debate Phase")
+        print("\nDebate Timeline:")
+        for i, entry in enumerate(result["debate_history"], 1):
+            log_agent(entry["speaker"], entry["content"])
+            if i < len(result["supervisor_notes"]):
+                log_agent("Supervisor", f"Analysis of Turn {i}:\n    {result['supervisor_notes'][i]}")
+        
+        # Print final supervisor analysis
+        log_step("Final Supervisor Analysis")
+        if result["supervisor_notes"]:
+            log_agent("Supervisor", result["supervisor_notes"][-1])
+        
+        # Print podcast results
+        log_step("Podcast Production Phase")
+        if "final_podcast" in result:
+            podcast_data = result["final_podcast"]
+            if "error" in podcast_data:
+                log_agent("Podcast", f"Error: {podcast_data['error']}")
+            else:
+                log_agent("Podcast", "Script:\n" + podcast_data["content"])
+                if podcast_data.get("audio_file"):
+                    audio_path = os.path.join(os.path.dirname(__file__), "audio_storage", podcast_data["audio_file"])
+                    file_size = os.path.getsize(audio_path) if os.path.exists(audio_path) else 0
+                    log_agent("Podcast", f"Audio file saved as: {podcast_data['audio_file']} (size: {file_size} bytes)")
+        
+        # Save results
+        log_step("Saving Results")
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"test_results_{timestamp}.json"
+        with open(filename, "w") as f:
+            json.dump({
+                "timestamp": datetime.now().isoformat(),
+                "query": test_query,
+                "workflow_results": result,
+                "transcript_saved": transcript_success,
+                "transcript_status": transcript_message
+            }, f, indent=2)
+        log_step("Results Saved", f"File: {filename}")
+            
+    except Exception as e:
+        log_step("ERROR", f"Workflow execution failed: {str(e)}")
+        print("\nFull traceback:")
+        print(traceback.format_exc())
+        raise
+
+if __name__ == "__main__":
+    print("\n" + "="*50)
+    print("🤖 Starting AI Debate Workflow Test")
+    print("="*50)
+    
+    try:
+        asyncio.run(test_workflow())
+        print("\n" + "="*50)
+        print("✅ Test Complete")
+        print("="*50)
+        
+        # Run comprehensive tests
+        print("\nRunning comprehensive tests...")
+        asyncio.run(run_all_tests())
+        print("\n" + "="*50)
+        print("✅ All Tests Complete")
+        print("="*50)
+    except Exception as e:
+        print("\n" + "="*50)
+        print(f"❌ Tests Failed: {str(e)}")
+        print("="*50)
+        raise 

server/transcripts/podcasts.json

@@ -0,0 +1 @@
+[]

server/workflow.py

@@ -0,0 +1,254 @@
+from typing import Dict, Any, List, Annotated, TypedDict, Union, Optional
+from langgraph.graph import Graph, END
+from agents import create_agents
+import os
+from dotenv import load_dotenv
+import json
+import uuid
+
+# Load environment variables
+load_dotenv()
+
+# 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):
+            with open(TRANSCRIPTS_FILE, 'r') as f:
+                transcripts = json.load(f)
+        else:
+            transcripts = []
+        
+        # Append new transcript
+        transcripts.append(transcript)
+        
+        # Save updated transcripts
+        with open(TRANSCRIPTS_FILE, 'w') as f:
+            json.dump(transcripts, f, indent=2)
+            
+    except Exception as e:
+        print(f"Error saving transcript: {str(e)}")
+
+class AgentState(TypedDict):
+    messages: List[Dict[str, Any]]
+    current_agent: str
+    debate_turns: int
+    extractor_data: Dict[str, Any]
+    debate_history: List[Dict[str, Any]]
+    supervisor_notes: List[str]
+    supervisor_chunks: List[Dict[str, List[str]]]
+    final_podcast: Dict[str, Any]
+    agent_type: str
+    context: Optional[Dict[str, Any]]
+
+def create_workflow(tavily_api_key: str):
+    # Initialize all agents
+    agents = create_agents(tavily_api_key)
+    
+    # Create the graph
+    workflow = Graph()
+    
+    # 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}")
+        
+        try:
+            response = await agents["extractor"](query)
+            print(f"Extractor response: {response}")
+            
+            # Update state
+            state["extractor_data"] = response
+            
+            # Get initial supervisor analysis
+            supervisor_analysis = await agents["supervisor"]({
+                "extractor": response,
+                "skeptic": {"content": "Not started"},
+                "believer": {"content": "Not started"}
+            })
+            print(f"Initial supervisor analysis: {supervisor_analysis}")
+            
+            state["supervisor_notes"].append(supervisor_analysis["content"])
+            state["supervisor_chunks"].append(supervisor_analysis.get("chunks", {}))
+            
+            # Move to debate phase
+            state["current_agent"] = "debate"
+            return state
+        except Exception as e:
+            print(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']}")
+        
+        try:
+            if state["debate_turns"] == 0:
+                # First turn: both agents respond to extractor
+                print("Starting first debate turn")
+                
+                # If we have context, use it to inform the agents' responses
+                context = state.get("context", {})
+                agent_chunks = context.get("agent_chunks", []) if context else []
+                
+                # Create context-aware input for agents
+                context_input = {
+                    "content": state["extractor_data"]["content"],
+                    "chunks": agent_chunks
+                }
+                
+                skeptic_response = await agents["skeptic"](context_input)
+                believer_response = await agents["believer"](context_input)
+                
+                state["debate_history"].extend([
+                    {"speaker": "skeptic", "content": skeptic_response["content"]},
+                    {"speaker": "believer", "content": believer_response["content"]}
+                ])
+                print(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"]:
+                    current_speaker = state["agent_type"]
+                else:
+                    # Default alternating behavior
+                    last_speaker = state["debate_history"][-1]["speaker"]
+                    current_speaker = "believer" if last_speaker == "skeptic" else "skeptic"
+                
+                print(f"Processing response for {current_speaker}")
+                
+                # Create context-aware input
+                context = state.get("context", {})
+                agent_chunks = context.get("agent_chunks", []) if context else []
+                context_input = {
+                    "content": state["debate_history"][-1]["content"],
+                    "chunks": agent_chunks
+                }
+                
+                response = await agents[current_speaker](context_input)
+                
+                state["debate_history"].append({
+                    "speaker": current_speaker,
+                    "content": response["content"]
+                })
+                print(f"Added response: {state['debate_history'][-1]}")
+            
+            # Add supervisor note and chunks
+            supervisor_analysis = await agents["supervisor"]({
+                "extractor": state["extractor_data"],
+                "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}")
+            
+            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")
+            
+            # End the workflow after 2 debate turns
+            if state["debate_turns"] >= 2:
+                state["current_agent"] = "podcast"
+                print("Moving to podcast production")
+            
+            return state
+        except Exception as e:
+            print(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")
+        
+        try:
+            # Create podcast from debate
+            podcast_result = await agents["podcast_producer"](
+                state["debate_history"],
+                state["supervisor_notes"],
+                state["messages"][-1]["content"],  # Pass the original user query
+                state["supervisor_chunks"],
+                {}  # Empty quadrant analysis since we removed storage manager
+            )
+            print(f"Podcast production result: {podcast_result}")
+            
+            # Save transcript to JSON file
+            save_transcript(
+                podcast_script=podcast_result["content"],
+                user_query=state["messages"][-1]["content"]
+            )
+            
+            # Store the result
+            state["final_podcast"] = podcast_result
+            
+            # End the workflow
+            state["current_agent"] = END
+            return state
+        except Exception as e:
+            print(f"Error in podcast production: {str(e)}")
+            raise Exception(f"Error in podcast production: {str(e)}")
+
+    # Add nodes to the graph
+    workflow.add_node("extractor", run_extractor)
+    workflow.add_node("debate", run_debate)
+    workflow.add_node("podcast", run_podcast_producer)
+
+    # Set the entry point
+    workflow.set_entry_point("extractor")
+
+    # Add edges
+    workflow.add_edge("extractor", "debate")
+    
+    # Add conditional edges for debate
+    workflow.add_conditional_edges(
+        "debate",
+        lambda x: "podcast" if x["debate_turns"] >= 2 else "debate"
+    )
+    
+    # Add edge from podcast to end
+    workflow.add_edge("podcast", END)
+
+    # Compile the graph
+    return workflow.compile()
+
+async def run_workflow(
+    graph: Graph, 
+    query: str, 
+    agent_type: str = "believer",
+    context: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """Run the workflow with a given query."""
+    # Initialize the state
+    initial_state = {
+        "messages": [{"role": "user", "content": query}],
+        "current_agent": "extractor",
+        "debate_turns": 0,
+        "extractor_data": {},
+        "debate_history": [],
+        "supervisor_notes": [],
+        "supervisor_chunks": [],
+        "final_podcast": {},
+        "agent_type": agent_type,
+        "context": context
+    }
+    
+    # Run the graph
+    result = await graph.ainvoke(initial_state)
+    
+    return {
+        "debate_history": result["debate_history"],
+        "supervisor_notes": result["supervisor_notes"],
+        "supervisor_chunks": result["supervisor_chunks"],
+        "extractor_data": result["extractor_data"],
+        "final_podcast": result["final_podcast"]
+    }