feat: initial MVP of Ask The Right Question app

- Add audio transcription via OpenAI Whisper API
- Add context accumulation system for tracking talk content
- Add research tools via Tavily API (web search, news,
fact-check)
- Add Claude agent with tool use for question generation
- Add Gradio 6 UI with microphone input and text paste options
- Add question categorization (Clarification, Depth, Connection,
etc.)
- Configure for HuggingFace Spaces deployment

.env.example

@@ -0,0 +1,8 @@
+# OpenAI API Key (for Whisper transcription)
+OPENAI_API_KEY=your_openai_api_key_here
+
+# Anthropic API Key (for Claude agent)
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Tavily API Key (for web search/research)
+TAVILY_API_KEY=your_tavily_api_key_here

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,51 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# Environment variables
+.env
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Misc
+*.bak
+*.tmp

.python-version

@@ -0,0 +1 @@
+3.13

README.md

@@ -1,13 +1,159 @@
 ---
 title: Ask The Right Question
-emoji: 📊
-colorFrom: blue
+emoji: 🎤
+colorFrom: purple
 colorTo: indigo
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: "5.50.0"
 app_file: app.py
 pinned: false
-short_description: Listen to a talk and suggest quality questions to ask
+tags:
+  - mcp-in-action-track-consumer
+  - agents
+  - question-generation
+  - q-and-a
+  - critical-thinking
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Ask The Right Question
+
+> AI-powered assistant that helps you ask insightful questions during Q&A sessions at conferences, classes, and talks.
+
+## The Problem
+
+You're at a conference, a class, or a talk. The speaker finishes and opens the floor for questions. Your mind goes blank. You want to:
+- Ask something meaningful that shows you were engaged
+- Make a connection with the speaker
+- Actually learn something valuable from the Q&A
+
+But coming up with good questions on the spot is hard.
+
+## The Solution
+
+**Ask The Right Question** listens to the talk and helps you generate thoughtful, well-researched questions. It:
+
+1. **Captures Context** - Record audio snippets or paste notes from the talk
+2. **Researches** - Automatically researches the speaker's background, fact-checks claims, and finds relevant trends
+3. **Generates Questions** - Creates insightful questions with explanations of *why* they're good
+4. **Teaches Critical Thinking** - Helps you understand what makes a question valuable
+
+## Features
+
+### Core Features (MVP)
+- Live microphone capture with OpenAI Whisper transcription
+- Context accumulation as the talk progresses
+- AI-powered question generation with Claude
+- Web research via Tavily (speaker background, fact-checking, trends)
+- Question categorization (Clarification, Depth, Connection, Challenge, Practical, Forward)
+- Explanation of why each question is valuable
+
+### Stretch Goals
+- Fill-in-the-blank questions for learning
+- Question ranking exercises
+- Gamification to build critical thinking skills
+
+## How It Works
+
+```
++----------------+     +------------------+     +-----------------+
+|  Microphone    | --> |  Transcription   | --> |  Context Store  |
+|  (Gradio)      |     |  (OpenAI Whisper)|     |  (Accumulating) |
++----------------+     +------------------+     +--------+--------+
+                                                        |
+                       +--------------------------------+--------+
+                       |                                v        |
+                       |  +-------------+    +----------------+  |
+                       |  | Tavily API  |    | Claude Agent   |  |
+                       |  | - Web Search| -> | Question Gen   |  |
+                       |  | - News      |    +-------+--------+  |
+                       |  | - Fact Check|            |           |
+                       |  +-------------+            |           |
+                       |        Agent Loop           |           |
+                       +-----------------------------+-----------+
+                                                     |
+                                                     v
+                                           +-----------------+
+                                           |   Gradio UI     |
+                                           |   - Questions   |
+                                           |   - Explanations|
+                                           +-----------------+
+```
+
+## Question Categories
+
+| Category | Description | Example |
+|----------|-------------|---------|
+| **CLARIFICATION** | Seeks to understand better | "Could you elaborate on what you meant by...?" |
+| **DEPTH** | Explores a topic more deeply | "What's the underlying mechanism behind...?" |
+| **CONNECTION** | Connects to other fields | "How does this relate to developments in...?" |
+| **CHALLENGE** | Probes assumptions respectfully | "Have you considered the alternative view that...?" |
+| **PRACTICAL** | Asks about real-world application | "How would this work in practice for...?" |
+| **FORWARD** | Explores future implications | "Where do you see this heading in the next...?" |
+
+## Tech Stack
+
+- **Frontend**: Gradio 6
+- **Transcription**: OpenAI Whisper API
+- **Agent LLM**: Claude (Anthropic)
+- **Research**: Tavily API (web search, news, fact-checking)
+- **Hosting**: HuggingFace Spaces
+
+## Setup
+
+### Environment Variables
+
+Create a `.env` file with:
+
+```bash
+OPENAI_API_KEY=your_openai_api_key
+ANTHROPIC_API_KEY=your_anthropic_api_key
+TAVILY_API_KEY=your_tavily_api_key
+```
+
+### Local Development
+
+```bash
+# Clone the repo
+git clone https://huggingface.co/spaces/YOUR_USERNAME/ask-the-right-question
+
+# Install dependencies
+uv sync
+
+# Run the app
+uv run python app.py
+```
+
+## Usage
+
+1. **Record Audio**: Click the microphone button to record snippets of the talk
+2. **Or Paste Text**: Manually paste notes or transcript
+3. **Add Speaker Info**: (Optional) Enter the speaker's name for background research
+4. **Generate Questions**: Click the button to get AI-generated questions
+5. **Learn**: Read the explanations to understand why each question is valuable
+
+## Demo Video
+
+[Coming soon]
+
+## Social Media Post
+
+[Link to social media post]
+
+## Team
+
+- [Your Name](https://huggingface.co/YOUR_USERNAME)
+
+## Acknowledgments
+
+Built for the HuggingFace MCP Hackathon (November 2024)
+
+Powered by:
+- [Anthropic Claude](https://anthropic.com) - AI reasoning and question generation
+- [OpenAI Whisper](https://openai.com) - Audio transcription
+- [Tavily](https://tavily.com) - AI-optimized web search
+- [Gradio](https://gradio.app) - UI framework
+- [HuggingFace](https://huggingface.co) - Hosting
+
+## License
+
+MIT

app.py

@@ -0,0 +1,319 @@
+"""
+Ask The Right Question - AI-powered Q&A Assistant
+
+An app that listens to talks/presentations and helps you generate
+insightful questions during Q&A sessions.
+"""
+
+import os
+import gradio as gr
+from dotenv import load_dotenv
+
+from src.transcription import transcribe_audio
+from src.context import ConversationContext
+from src.agent import analyze_and_generate_questions, extract_topics_and_claims
+
+# Load environment variables
+load_dotenv()
+
+# Global context (per session in production, use gr.State)
+context = ConversationContext()
+
+
+def process_audio(audio_path: str, state: dict) -> tuple[str, str, dict]:
+    """
+    Process audio input and update transcript.
+
+    Args:
+        audio_path: Path to recorded audio file
+        state: Current session state
+
+    Returns:
+        Tuple of (transcript, status message, updated state)
+    """
+    if not audio_path:
+        return state.get("transcript", ""), "No audio received", state
+
+    try:
+        # Transcribe the audio
+        new_text = transcribe_audio(audio_path)
+
+        if new_text.strip():
+            # Get context from state
+            ctx = state.get("context")
+            if ctx is None:
+                ctx = ConversationContext()
+                state["context"] = ctx
+
+            # Add to context
+            ctx.add_transcript(new_text)
+
+            # Update transcript display
+            full_transcript = ctx.get_full_transcript()
+            state["transcript"] = full_transcript
+
+            # Get context summary
+            summary = ctx.get_context_summary()
+            status = f"Transcribed {summary['num_segments']} segments ({summary['transcript_length']} chars)"
+
+            # Auto-extract topics if enough context
+            if ctx.has_enough_context(min_words=50) and len(ctx.identified_topics) == 0:
+                extract_topics_and_claims(ctx)
+                if ctx.identified_topics:
+                    status += f" | Topics: {', '.join(ctx.identified_topics[:3])}"
+
+            return full_transcript, status, state
+
+    except Exception as e:
+        return state.get("transcript", ""), f"Error: {str(e)}", state
+
+    return state.get("transcript", ""), "Processing...", state
+
+
+def generate_questions(
+    speaker_name: str,
+    focus_area: str,
+    num_questions: int,
+    state: dict
+) -> tuple[str, str, dict]:
+    """
+    Generate questions based on accumulated context.
+
+    Args:
+        speaker_name: Optional speaker name
+        focus_area: Optional focus area
+        num_questions: Number of questions to generate
+        state: Current session state
+
+    Returns:
+        Tuple of (questions HTML, research summary, updated state)
+    """
+    ctx = state.get("context")
+    if ctx is None or not ctx.has_enough_context(min_words=30):
+        return "Need more context. Please record more of the talk.", "", state
+
+    try:
+        result = analyze_and_generate_questions(
+            context=ctx,
+            speaker_name=speaker_name,
+            num_questions=int(num_questions),
+            focus_area=focus_area
+        )
+
+        # Format questions as HTML
+        questions_html = f"<h3>Analysis</h3><p>{result.get('analysis', '')}</p>"
+        questions_html += "<h3>Suggested Questions</h3>"
+
+        for i, q in enumerate(result.get("questions", []), 1):
+            category = q.get("category", "GENERAL")
+            question = q.get("question", "")
+            reasoning = q.get("reasoning", "")
+
+            questions_html += f"""
+            <div style="margin: 10px 0; padding: 15px; border-left: 4px solid #667eea; background: #f8f9fa; border-radius: 4px;">
+                <div style="font-size: 12px; color: #667eea; font-weight: bold; margin-bottom: 5px;">
+                    {category}
+                </div>
+                <div style="font-size: 16px; font-weight: 500; margin-bottom: 8px;">
+                    {i}. {question}
+                </div>
+                <div style="font-size: 14px; color: #666; font-style: italic;">
+                    Why this is good: {reasoning}
+                </div>
+            </div>
+            """
+
+        research_summary = result.get("research_summary", "")
+
+        return questions_html, research_summary, state
+
+    except Exception as e:
+        return f"Error generating questions: {str(e)}", "", state
+
+
+def clear_session(state: dict) -> tuple[str, str, str, str, dict]:
+    """Clear all session data."""
+    state["context"] = ConversationContext()
+    state["transcript"] = ""
+    return "", "", "", "Session cleared", state
+
+
+def add_manual_context(text: str, state: dict) -> tuple[str, str, dict]:
+    """Add manually typed context."""
+    if not text.strip():
+        return state.get("transcript", ""), "No text provided", state
+
+    ctx = state.get("context")
+    if ctx is None:
+        ctx = ConversationContext()
+        state["context"] = ctx
+
+    ctx.add_transcript(text)
+    full_transcript = ctx.get_full_transcript()
+    state["transcript"] = full_transcript
+
+    # Extract topics
+    if ctx.has_enough_context(min_words=50):
+        extract_topics_and_claims(ctx)
+
+    summary = ctx.get_context_summary()
+    status = f"Added context. Total: {summary['transcript_length']} chars"
+
+    return full_transcript, status, state
+
+
+# Custom CSS
+custom_css = """
+.main-container {
+    max-width: 1200px;
+    margin: 0 auto;
+}
+.header {
+    text-align: center;
+    padding: 20px;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border-radius: 10px;
+    margin-bottom: 20px;
+}
+.question-card {
+    background: #f8f9fa;
+    border-radius: 8px;
+    padding: 15px;
+    margin: 10px 0;
+    border-left: 4px solid #667eea;
+}
+"""
+
+# Build the Gradio interface
+with gr.Blocks(css=custom_css, title="Ask The Right Question") as demo:
+    # Session state
+    state = gr.State({"context": ConversationContext(), "transcript": ""})
+
+    # Header
+    gr.HTML("""
+    <div class="header">
+        <h1>Ask The Right Question</h1>
+        <p>AI-powered assistant to help you ask insightful questions during Q&A sessions</p>
+    </div>
+    """)
+
+    with gr.Row():
+        # Left column - Input
+        with gr.Column(scale=1):
+            gr.Markdown("### 1. Capture the Talk")
+
+            with gr.Tab("Record Audio"):
+                audio_input = gr.Audio(
+                    sources=["microphone"],
+                    type="filepath",
+                    label="Record from microphone",
+                    streaming=False
+                )
+                audio_status = gr.Textbox(label="Status", interactive=False)
+
+            with gr.Tab("Paste Text"):
+                manual_text = gr.Textbox(
+                    label="Paste transcript or notes",
+                    placeholder="Paste any context from the talk here...",
+                    lines=5
+                )
+                add_text_btn = gr.Button("Add Context", variant="secondary")
+
+            gr.Markdown("### 2. Transcript")
+            transcript_display = gr.Textbox(
+                label="Accumulated Transcript",
+                lines=10,
+                interactive=False,
+                placeholder="Transcript will appear here as you record..."
+            )
+
+            clear_btn = gr.Button("Clear Session", variant="stop")
+
+        # Right column - Questions
+        with gr.Column(scale=1):
+            gr.Markdown("### 3. Generate Questions")
+
+            with gr.Row():
+                speaker_name = gr.Textbox(
+                    label="Speaker Name (optional)",
+                    placeholder="e.g., Dr. Jane Smith",
+                    scale=2
+                )
+                num_questions = gr.Slider(
+                    minimum=3,
+                    maximum=10,
+                    value=5,
+                    step=1,
+                    label="Number of Questions",
+                    scale=1
+                )
+
+            focus_area = gr.Textbox(
+                label="Focus Area (optional)",
+                placeholder="e.g., practical applications, future trends..."
+            )
+
+            generate_btn = gr.Button("Generate Questions", variant="primary", size="lg")
+
+            gr.Markdown("### Suggested Questions")
+            questions_output = gr.HTML(
+                value="<p style='color: #666; text-align: center; padding: 40px;'>Questions will appear here after you record some context and click 'Generate Questions'</p>"
+            )
+
+            with gr.Accordion("Research Summary", open=False):
+                research_output = gr.Textbox(
+                    label="Research conducted by the AI",
+                    lines=5,
+                    interactive=False
+                )
+
+    # Footer
+    gr.Markdown("""
+    ---
+    **How to use:**
+    1. Click the microphone to record parts of a talk or paste text directly
+    2. The AI will accumulate context and identify topics
+    3. Optionally enter the speaker's name for background research
+    4. Click "Generate Questions" to get AI-suggested questions with explanations
+
+    **Tips for great questions:**
+    - Record key moments, not the entire talk
+    - Add speaker name for personalized research
+    - Use focus area to target specific themes
+
+    ---
+    Built for the Hugging Face MCP Hackathon | Powered by Claude, OpenAI Whisper, and Tavily
+    """)
+
+    # Event handlers
+    audio_input.change(
+        fn=process_audio,
+        inputs=[audio_input, state],
+        outputs=[transcript_display, audio_status, state]
+    )
+
+    add_text_btn.click(
+        fn=add_manual_context,
+        inputs=[manual_text, state],
+        outputs=[transcript_display, audio_status, state]
+    ).then(
+        fn=lambda: "",
+        outputs=[manual_text]
+    )
+
+    generate_btn.click(
+        fn=generate_questions,
+        inputs=[speaker_name, focus_area, num_questions, state],
+        outputs=[questions_output, research_output, state]
+    )
+
+    clear_btn.click(
+        fn=clear_session,
+        inputs=[state],
+        outputs=[transcript_display, questions_output, research_output, audio_status, state]
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

main.py

@@ -0,0 +1,6 @@
+"""Entry point for Ask The Right Question app."""
+
+from app import demo
+
+if __name__ == "__main__":
+    demo.launch()

pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "ask-the-right-question"
+version = "0.1.0"
+description = "AI-powered Q&A assistant that helps you ask insightful questions during talks and presentations"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "anthropic>=0.75.0",
+    "gradio>=5.50.0",
+    "openai>=2.8.1",
+    "python-dotenv>=1.2.1",
+    "tavily-python>=0.7.13",
+]
+
+[project.scripts]
+ask-the-right-question = "app:demo.launch"

requirements.txt

@@ -0,0 +1,5 @@
+anthropic>=0.75.0
+gradio>=5.50.0
+openai>=2.8.1
+python-dotenv>=1.2.1
+tavily-python>=0.7.13

src/__init__.py

@@ -0,0 +1 @@
+# Ask The Right Question - AI-powered Q&A assistant

src/agent.py

@@ -0,0 +1,358 @@
+"""Question generation agent using Claude."""
+
+import os
+import json
+from anthropic import Anthropic
+
+from .context import ConversationContext
+from .research import search_web, search_news, research_speaker, fact_check, get_topic_trends
+
+
+def get_anthropic_client() -> Anthropic:
+    """Get Anthropic client with API key from environment."""
+    api_key = os.getenv("ANTHROPIC_API_KEY")
+    if not api_key:
+        raise ValueError("ANTHROPIC_API_KEY environment variable not set")
+    return Anthropic(api_key=api_key)
+
+
+SYSTEM_PROMPT = """You are an expert at helping people ask insightful, thoughtful questions during Q&A sessions at conferences, classes, and talks.
+
+Your role is to:
+1. Analyze the conversation/talk context provided
+2. Identify key themes, claims, and areas worth exploring
+3. Generate high-quality questions that:
+   - Show genuine engagement with the material
+   - Demonstrate critical thinking
+   - Could lead to valuable insights
+   - Are respectful and constructive
+   - Help the asker make a positive impression
+
+Question Categories:
+- CLARIFICATION: Questions that seek to understand something better
+- DEPTH: Questions that explore a topic more deeply
+- CONNECTION: Questions that connect ideas to other fields or experiences
+- CHALLENGE: Respectful questions that probe assumptions or claims
+- PRACTICAL: Questions about real-world application
+- FORWARD: Questions about future implications or directions
+
+When generating questions, consider:
+- The speaker's expertise and background
+- Recent trends and developments in the field
+- Claims that could be fact-checked or explored further
+- Connections to current events or other domains
+
+You have access to research tools. Use them to:
+- Research the speaker's background
+- Fact-check interesting claims
+- Find recent trends in the topic
+- Discover relevant news or developments
+
+Always explain WHY a question is good - this helps users learn to ask better questions themselves."""
+
+
+TOOLS = [
+    {
+        "name": "search_web",
+        "description": "Search the web for information on any topic. Use this to research context, verify claims, or find relevant information.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "The search query"
+                }
+            },
+            "required": ["query"]
+        }
+    },
+    {
+        "name": "search_news",
+        "description": "Search for recent news articles on a topic. Use this to find current events or recent developments.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "The news search query"
+                },
+                "days": {
+                    "type": "integer",
+                    "description": "How many days back to search (default: 7)",
+                    "default": 7
+                }
+            },
+            "required": ["query"]
+        }
+    },
+    {
+        "name": "research_speaker",
+        "description": "Research a speaker's background, expertise, and recent activity.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "speaker_name": {
+                    "type": "string",
+                    "description": "Name of the speaker"
+                },
+                "topic": {
+                    "type": "string",
+                    "description": "Optional topic context"
+                }
+            },
+            "required": ["speaker_name"]
+        }
+    },
+    {
+        "name": "fact_check",
+        "description": "Fact-check a specific claim or statement made in the talk.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "claim": {
+                    "type": "string",
+                    "description": "The claim to verify"
+                }
+            },
+            "required": ["claim"]
+        }
+    },
+    {
+        "name": "get_topic_trends",
+        "description": "Get recent trends and developments in a specific topic area.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "topic": {
+                    "type": "string",
+                    "description": "The topic to research"
+                }
+            },
+            "required": ["topic"]
+        }
+    }
+]
+
+
+def execute_tool(tool_name: str, tool_input: dict) -> str:
+    """Execute a tool and return the result as a string."""
+    try:
+        if tool_name == "search_web":
+            result = search_web(tool_input["query"])
+        elif tool_name == "search_news":
+            result = search_news(tool_input["query"], days=tool_input.get("days", 7))
+        elif tool_name == "research_speaker":
+            result = research_speaker(
+                tool_input["speaker_name"],
+                topic=tool_input.get("topic", "")
+            )
+        elif tool_name == "fact_check":
+            result = fact_check(tool_input["claim"])
+        elif tool_name == "get_topic_trends":
+            result = get_topic_trends(tool_input["topic"])
+        else:
+            return f"Unknown tool: {tool_name}"
+
+        # Extract relevant info from result
+        if isinstance(result, dict):
+            if "answer" in result:
+                return f"Summary: {result['answer']}\n\nSources: {json.dumps(result.get('results', [])[:3], indent=2)}"
+            return json.dumps(result, indent=2)
+        return str(result)
+
+    except Exception as e:
+        return f"Error executing {tool_name}: {str(e)}"
+
+
+def analyze_and_generate_questions(
+    context: ConversationContext,
+    speaker_name: str = "",
+    num_questions: int = 5,
+    focus_area: str = ""
+) -> dict:
+    """
+    Analyze context and generate insightful questions.
+
+    Args:
+        context: The conversation context
+        speaker_name: Optional speaker name to research
+        num_questions: Number of questions to generate
+        focus_area: Optional area to focus questions on
+
+    Returns:
+        Dictionary with questions and analysis
+    """
+    client = get_anthropic_client()
+
+    # Build the user message
+    user_message = f"""Based on the following context from a talk/presentation, generate {num_questions} insightful questions.
+
+{context.to_prompt_context()}
+
+"""
+
+    if speaker_name:
+        user_message += f"\nSpeaker name: {speaker_name} (please research their background)"
+
+    if focus_area:
+        user_message += f"\nFocus area: {focus_area}"
+
+    user_message += """
+
+Please:
+1. First, use the research tools to gather additional context (speaker background, fact-check claims, find trends)
+2. Then generate questions with explanations of why each is valuable
+3. Categorize each question (CLARIFICATION, DEPTH, CONNECTION, CHALLENGE, PRACTICAL, FORWARD)
+4. Format your response as a JSON object with this structure:
+{
+    "analysis": "Brief analysis of the talk's key themes",
+    "questions": [
+        {
+            "question": "The question text",
+            "category": "CATEGORY",
+            "reasoning": "Why this is a good question",
+            "based_on": "What context/research this was based on"
+        }
+    ],
+    "research_summary": "Summary of research conducted"
+}"""
+
+    messages = [{"role": "user", "content": user_message}]
+
+    # Agent loop with tool use
+    max_iterations = 10
+    iteration = 0
+
+    while iteration < max_iterations:
+        iteration += 1
+
+        response = client.messages.create(
+            model="claude-sonnet-4-20250514",
+            max_tokens=4096,
+            system=SYSTEM_PROMPT,
+            tools=TOOLS,
+            messages=messages
+        )
+
+        # Check if we need to handle tool use
+        if response.stop_reason == "tool_use":
+            # Process tool calls
+            tool_results = []
+            assistant_content = response.content
+
+            for block in response.content:
+                if block.type == "tool_use":
+                    tool_result = execute_tool(block.name, block.input)
+                    tool_results.append({
+                        "type": "tool_result",
+                        "tool_use_id": block.id,
+                        "content": tool_result
+                    })
+
+                    # Store research in context
+                    if block.name in ["search_web", "search_news", "fact_check", "get_topic_trends"]:
+                        context.add_research(
+                            query=str(block.input),
+                            summary=tool_result[:500]  # First 500 chars
+                        )
+
+            # Add assistant response and tool results to messages
+            messages.append({"role": "assistant", "content": assistant_content})
+            messages.append({"role": "user", "content": tool_results})
+
+        else:
+            # No more tool use, extract final response
+            final_text = ""
+            for block in response.content:
+                if hasattr(block, "text"):
+                    final_text += block.text
+
+            # Try to parse JSON from response
+            try:
+                # Find JSON in response
+                json_start = final_text.find("{")
+                json_end = final_text.rfind("}") + 1
+                if json_start >= 0 and json_end > json_start:
+                    json_str = final_text[json_start:json_end]
+                    result = json.loads(json_str)
+
+                    # Store questions in context
+                    for q in result.get("questions", []):
+                        context.add_question(
+                            question=q["question"],
+                            category=q.get("category", "general"),
+                            reasoning=q.get("reasoning", "")
+                        )
+
+                    return result
+            except json.JSONDecodeError:
+                pass
+
+            # Return raw text if JSON parsing fails
+            return {
+                "analysis": "Could not parse structured response",
+                "questions": [{"question": final_text, "category": "general", "reasoning": ""}],
+                "research_summary": ""
+            }
+
+    return {
+        "analysis": "Max iterations reached",
+        "questions": [],
+        "research_summary": ""
+    }
+
+
+def extract_topics_and_claims(context: ConversationContext) -> dict:
+    """
+    Extract key topics and claims from the transcript.
+
+    Args:
+        context: The conversation context
+
+    Returns:
+        Dictionary with topics and claims
+    """
+    client = get_anthropic_client()
+
+    transcript = context.get_full_transcript()
+    if not transcript:
+        return {"topics": [], "claims": []}
+
+    response = client.messages.create(
+        model="claude-sonnet-4-20250514",
+        max_tokens=1024,
+        messages=[{
+            "role": "user",
+            "content": f"""Analyze this transcript and extract:
+1. Key topics being discussed
+2. Notable claims or statements that could be fact-checked or explored
+
+Transcript:
+{transcript}
+
+Respond in JSON format:
+{{
+    "topics": ["topic1", "topic2", ...],
+    "claims": ["claim1", "claim2", ...]
+}}"""
+        }]
+    )
+
+    try:
+        text = response.content[0].text
+        json_start = text.find("{")
+        json_end = text.rfind("}") + 1
+        if json_start >= 0 and json_end > json_start:
+            result = json.loads(text[json_start:json_end])
+
+            # Update context
+            for topic in result.get("topics", []):
+                context.add_topic(topic)
+            for claim in result.get("claims", []):
+                context.add_claim(claim)
+
+            return result
+    except (json.JSONDecodeError, IndexError):
+        pass
+
+    return {"topics": [], "claims": []}

src/context.py

@@ -0,0 +1,161 @@
+"""Context accumulation and management for conversation tracking."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class TranscriptSegment:
+    """A segment of transcribed text."""
+    text: str
+    timestamp: datetime = field(default_factory=datetime.now)
+
+
+@dataclass
+class SpeakerInfo:
+    """Information about the speaker."""
+    name: str = ""
+    background: str = ""
+    expertise: list[str] = field(default_factory=list)
+    recent_activity: str = ""
+
+
+@dataclass
+class ResearchResult:
+    """A research result from web search."""
+    query: str
+    summary: str
+    sources: list[dict] = field(default_factory=list)
+    timestamp: datetime = field(default_factory=datetime.now)
+
+
+class ConversationContext:
+    """Manages accumulated context from a talk/conversation."""
+
+    def __init__(self):
+        self.transcript_segments: list[TranscriptSegment] = []
+        self.speaker_info: Optional[SpeakerInfo] = None
+        self.research_results: list[ResearchResult] = []
+        self.identified_topics: list[str] = []
+        self.key_claims: list[str] = []
+        self.generated_questions: list[dict] = []
+        self.session_start: datetime = datetime.now()
+
+    def add_transcript(self, text: str) -> None:
+        """Add a new transcript segment."""
+        if text.strip():
+            self.transcript_segments.append(TranscriptSegment(text=text.strip()))
+
+    def get_full_transcript(self) -> str:
+        """Get the complete transcript as a single string."""
+        return " ".join(seg.text for seg in self.transcript_segments)
+
+    def get_recent_transcript(self, num_segments: int = 5) -> str:
+        """Get the most recent transcript segments."""
+        recent = self.transcript_segments[-num_segments:]
+        return " ".join(seg.text for seg in recent)
+
+    def set_speaker(self, name: str, background: str = "", expertise: list[str] = None,
+                    recent_activity: str = "") -> None:
+        """Set speaker information."""
+        self.speaker_info = SpeakerInfo(
+            name=name,
+            background=background,
+            expertise=expertise or [],
+            recent_activity=recent_activity
+        )
+
+    def add_research(self, query: str, summary: str, sources: list[dict] = None) -> None:
+        """Add a research result."""
+        self.research_results.append(ResearchResult(
+            query=query,
+            summary=summary,
+            sources=sources or []
+        ))
+
+    def add_topic(self, topic: str) -> None:
+        """Add an identified topic."""
+        if topic not in self.identified_topics:
+            self.identified_topics.append(topic)
+
+    def add_claim(self, claim: str) -> None:
+        """Add a key claim from the talk."""
+        if claim not in self.key_claims:
+            self.key_claims.append(claim)
+
+    def add_question(self, question: str, category: str = "general",
+                     reasoning: str = "") -> None:
+        """Add a generated question."""
+        self.generated_questions.append({
+            "question": question,
+            "category": category,
+            "reasoning": reasoning,
+            "timestamp": datetime.now().isoformat()
+        })
+
+    def get_context_summary(self) -> dict:
+        """Get a summary of all accumulated context."""
+        return {
+            "transcript_length": len(self.get_full_transcript()),
+            "num_segments": len(self.transcript_segments),
+            "speaker": self.speaker_info.name if self.speaker_info else None,
+            "topics": self.identified_topics,
+            "claims_count": len(self.key_claims),
+            "research_count": len(self.research_results),
+            "questions_generated": len(self.generated_questions),
+            "session_duration": (datetime.now() - self.session_start).seconds
+        }
+
+    def has_enough_context(self, min_words: int = 100) -> bool:
+        """Check if we have enough context to start generating questions."""
+        transcript = self.get_full_transcript()
+        word_count = len(transcript.split())
+        return word_count >= min_words
+
+    def to_prompt_context(self) -> str:
+        """Format context for use in LLM prompts."""
+        parts = []
+
+        # Transcript
+        transcript = self.get_full_transcript()
+        if transcript:
+            parts.append(f"## Transcript\n{transcript}")
+
+        # Speaker info
+        if self.speaker_info and self.speaker_info.name:
+            speaker_section = f"## Speaker: {self.speaker_info.name}"
+            if self.speaker_info.background:
+                speaker_section += f"\nBackground: {self.speaker_info.background}"
+            if self.speaker_info.expertise:
+                speaker_section += f"\nExpertise: {', '.join(self.speaker_info.expertise)}"
+            if self.speaker_info.recent_activity:
+                speaker_section += f"\nRecent Activity: {self.speaker_info.recent_activity}"
+            parts.append(speaker_section)
+
+        # Topics
+        if self.identified_topics:
+            parts.append(f"## Topics Discussed\n" + "\n".join(f"- {t}" for t in self.identified_topics))
+
+        # Key claims
+        if self.key_claims:
+            parts.append(f"## Key Claims Made\n" + "\n".join(f"- {c}" for c in self.key_claims))
+
+        # Research
+        if self.research_results:
+            research_section = "## Research Findings"
+            for r in self.research_results[-3:]:  # Last 3 research results
+                research_section += f"\n\n### {r.query}\n{r.summary}"
+            parts.append(research_section)
+
+        return "\n\n".join(parts)
+
+    def clear(self) -> None:
+        """Reset all context."""
+        self.transcript_segments = []
+        self.speaker_info = None
+        self.research_results = []
+        self.identified_topics = []
+        self.key_claims = []
+        self.generated_questions = []
+        self.session_start = datetime.now()

src/research.py

@@ -0,0 +1,147 @@
+"""Research tools using Tavily API for web search and content extraction."""
+
+import os
+from tavily import TavilyClient
+
+
+def get_tavily_client() -> TavilyClient:
+    """Get Tavily client with API key from environment."""
+    api_key = os.getenv("TAVILY_API_KEY")
+    if not api_key:
+        raise ValueError("TAVILY_API_KEY environment variable not set")
+    return TavilyClient(api_key=api_key)
+
+
+def search_web(query: str, max_results: int = 5, search_depth: str = "basic") -> dict:
+    """
+    Search the web for information.
+
+    Args:
+        query: Search query
+        max_results: Maximum number of results
+        search_depth: "basic" or "advanced"
+
+    Returns:
+        Search results with title, url, and content
+    """
+    client = get_tavily_client()
+
+    response = client.search(
+        query=query,
+        search_depth=search_depth,
+        max_results=max_results,
+        include_answer=True
+    )
+
+    return response
+
+
+def search_news(query: str, max_results: int = 5, days: int = 7) -> dict:
+    """
+    Search for recent news articles.
+
+    Args:
+        query: Search query
+        max_results: Maximum number of results
+        days: How many days back to search
+
+    Returns:
+        News search results
+    """
+    client = get_tavily_client()
+
+    response = client.search(
+        query=query,
+        topic="news",
+        days=days,
+        max_results=max_results,
+        include_answer=True
+    )
+
+    return response
+
+
+def research_speaker(speaker_name: str, topic: str = "") -> dict:
+    """
+    Research a speaker's background.
+
+    Args:
+        speaker_name: Name of the speaker
+        topic: Optional topic context
+
+    Returns:
+        Combined research results
+    """
+    client = get_tavily_client()
+
+    # Search for speaker background
+    query = f"{speaker_name} professional background expertise"
+    if topic:
+        query += f" {topic}"
+
+    background = client.search(
+        query=query,
+        search_depth="advanced",
+        max_results=5,
+        include_answer=True
+    )
+
+    # Search for recent news/activity
+    news_query = f"{speaker_name} recent news talks publications"
+    recent = client.search(
+        query=news_query,
+        topic="news",
+        days=30,
+        max_results=3,
+        include_answer=True
+    )
+
+    return {
+        "background": background,
+        "recent_activity": recent
+    }
+
+
+def fact_check(claim: str) -> dict:
+    """
+    Fact-check a claim or statement.
+
+    Args:
+        claim: The claim to verify
+
+    Returns:
+        Search results related to the claim
+    """
+    client = get_tavily_client()
+
+    response = client.search(
+        query=f"fact check: {claim}",
+        search_depth="advanced",
+        max_results=5,
+        include_answer=True
+    )
+
+    return response
+
+
+def get_topic_trends(topic: str) -> dict:
+    """
+    Get recent trends and developments in a topic.
+
+    Args:
+        topic: The topic to research
+
+    Returns:
+        Recent developments and trends
+    """
+    client = get_tavily_client()
+
+    response = client.search(
+        query=f"{topic} recent developments trends 2024 2025",
+        topic="news",
+        days=30,
+        max_results=5,
+        include_answer=True
+    )
+
+    return response

src/transcription.py

@@ -0,0 +1,56 @@
+"""Audio transcription using OpenAI Whisper API."""
+
+import os
+from openai import OpenAI
+
+
+def get_openai_client() -> OpenAI:
+    """Get OpenAI client with API key from environment."""
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        raise ValueError("OPENAI_API_KEY environment variable not set")
+    return OpenAI(api_key=api_key)
+
+
+def transcribe_audio(audio_path: str) -> str:
+    """
+    Transcribe audio file using OpenAI Whisper API.
+
+    Args:
+        audio_path: Path to audio file (mp3, wav, webm, etc.)
+
+    Returns:
+        Transcribed text
+    """
+    client = get_openai_client()
+
+    with open(audio_path, "rb") as audio_file:
+        transcription = client.audio.transcriptions.create(
+            model="whisper-1",
+            file=audio_file,
+            response_format="text"
+        )
+
+    return transcription
+
+
+def transcribe_audio_chunk(audio_data: bytes, filename: str = "audio.webm") -> str:
+    """
+    Transcribe audio data directly from bytes.
+
+    Args:
+        audio_data: Raw audio bytes
+        filename: Filename hint for format detection
+
+    Returns:
+        Transcribed text
+    """
+    client = get_openai_client()
+
+    transcription = client.audio.transcriptions.create(
+        model="whisper-1",
+        file=(filename, audio_data),
+        response_format="text"
+    )
+
+    return transcription