feat: add configurable LLM provider support (OpenAI/Anthropic)

- Add config.yaml for switching between OpenAI and Anthropic
providers
- Support gpt-5-mini with max_completion_tokens parameter
- Add strict mode to OpenAI tool definitions for newer models
- Add loguru for better error logging in terminal
- Update README with solved challenges

README.md

@@ -154,24 +154,20 @@ Powered by:
 - [Gradio](https://gradio.app) - UI framework
 - [HuggingFace](https://huggingface.co) - Hosting
 
-## Challenges
+## Challenges & Solutions
 
-### Audio Transcription Timing Issues
+### Audio Transcription Timing Issues (Solved ✅)
 
-The current implementation uses short audio chunk intervals for streaming transcription. However, this creates a significant problem:
+**Original problem:** Short audio chunk intervals caused the transcription API to fall behind, resulting in fragmented audio and information loss.
 
-- **Issue**: The transcription API cannot process chunks fast enough before the next chunk arrives
-- **Result**: Only fragments of audio are being transcribed, causing substantial information loss
-- **Impact**: The accumulated context is incomplete, leading to lower quality question generation
+**Solutions implemented:**
+- ✅ **20-second audio chunks** - Longer intervals give Whisper more context and reduce API calls
+- ✅ **2-second overlap** - Prevents word cutoffs at chunk boundaries
+- ✅ **Background threading** - Transcription and question generation run in separate threads
+- ✅ **Sequential queue** - Ensures transcriptions complete in order while audio keeps buffering
 
 ## To-Do
 
-### High Priority
-
-- [ ] **Experiment with audio buffering** - Implement a buffer that accumulates audio before sending to transcription API
-- [ ] **Increase audio chunk interval** - Test longer intervals (e.g., 5-10 seconds instead of 1-2 seconds) to allow complete transcription
-- [ ] **Add overlap between chunks** - Implement overlapping audio segments to prevent word cutoffs at boundaries
-
 ### Future Improvements
 
 - [ ] **Add useful MCPs** - Integrate additional MCP servers for enhanced capabilities:

config.yaml

@@ -0,0 +1,9 @@
+# LLM Configuration
+llm:
+  provider: openai  # "openai" or "anthropic"
+
+  openai:
+    model: gpt-5-mini
+
+  anthropic:
+    model: claude-sonnet-4-20250514

pyproject.toml

@@ -7,8 +7,10 @@ requires-python = ">=3.10"
 dependencies = [
     "anthropic>=0.75.0",
     "gradio>=5.50.0",
+    "loguru>=0.7.3",
     "openai>=2.8.1",
     "python-dotenv>=1.2.1",
+    "pyyaml>=6.0",
     "tavily-python>=0.7.13",
 ]
 

src/streaming_agent.py

@@ -2,18 +2,40 @@
 
 import os
 import json
-from anthropic import Anthropic
+import yaml
+from pathlib import Path
+from loguru import logger
 
 from .context import ConversationContext
 from .research import search_web, search_news, research_speaker
 
 
-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)
+def load_config() -> dict:
+    """Load configuration from config.yaml."""
+    config_path = Path(__file__).parent.parent / "config.yaml"
+    if config_path.exists():
+        with open(config_path) as f:
+            return yaml.safe_load(f)
+    return {"llm": {"provider": "openai", "openai": {"model": "gpt-4o-mini"}}}
+
+
+def get_llm_client():
+    """Get LLM client based on config."""
+    config = load_config()
+    provider = config.get("llm", {}).get("provider", "openai")
+
+    if provider == "anthropic":
+        from anthropic import Anthropic
+        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), provider, config["llm"]["anthropic"]["model"]
+    else:
+        from openai import OpenAI
+        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), provider, config["llm"]["openai"]["model"]
 
 
 # Concise system prompt optimized for streaming
@@ -27,7 +49,8 @@ Output JSON only:
 {"questions": [{"q": "question text", "type": "TYPE", "why": "brief reason"}]}"""
 
 
-TOOLS = [
+# Anthropic tools format
+ANTHROPIC_TOOLS = [
     {
         "name": "search_web",
         "description": "Search web for context. Use sparingly.",
@@ -57,6 +80,52 @@ TOOLS = [
     }
 ]
 
+# OpenAI tools format
+OPENAI_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "search_web",
+            "description": "Search web for context. Use sparingly.",
+            "strict": True,
+            "parameters": {
+                "type": "object",
+                "properties": {"query": {"type": "string"}},
+                "required": ["query"],
+                "additionalProperties": False
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "search_news",
+            "description": "Search recent news. Use sparingly.",
+            "strict": True,
+            "parameters": {
+                "type": "object",
+                "properties": {"query": {"type": "string"}},
+                "required": ["query"],
+                "additionalProperties": False
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "research_speaker",
+            "description": "Research speaker background.",
+            "strict": True,
+            "parameters": {
+                "type": "object",
+                "properties": {"speaker_name": {"type": "string"}},
+                "required": ["speaker_name"],
+                "additionalProperties": False
+            }
+        }
+    }
+]
+
 TOOL_DISPLAY = {
     "search_web": {"icon": "🔍", "name": "Web Search"},
     "search_news": {"icon": "📰", "name": "News Search"},
@@ -166,6 +235,7 @@ def generate_questions_sync(
 ) -> tuple[list[dict], list[dict], str, str]:
     """
     Generate new questions synchronously (non-generator version).
+    Supports both OpenAI and Anthropic providers based on config.
 
     Args:
         context: Current conversation context
@@ -176,7 +246,7 @@ def generate_questions_sync(
     Returns:
         Tuple of (all_questions, updated_activity_log, questions_html, log_html)
     """
-    client = get_anthropic_client()
+    client, provider, model = get_llm_client()
 
     # Add thinking activity
     activity_log.append({"type": "thinking"})
@@ -199,73 +269,23 @@ Already asked (avoid similar):
 
 Generate 1-3 NEW insightful questions based on the recent content. Be concise."""
 
-    messages = [{"role": "user", "content": user_message}]
-
     # Limit iterations for speed
     max_iterations = 3
     iteration = 0
     new_questions = []
 
     try:
-        while iteration < max_iterations:
-            iteration += 1
-
-            response = client.messages.create(
-                model="claude-sonnet-4-20250514",
-                max_tokens=1024,
-                system=STREAMING_SYSTEM_PROMPT,
-                tools=TOOLS,
-                messages=messages
+        if provider == "anthropic":
+            new_questions = _generate_with_anthropic(
+                client, model, user_message, activity_log, context, max_iterations
+            )
+        else:
+            new_questions = _generate_with_openai(
+                client, model, user_message, activity_log, context, max_iterations
             )
-
-            if response.stop_reason == "tool_use":
-                tool_results = []
-                for block in response.content:
-                    if block.type == "tool_use":
-                        query = block.input.get("query", block.input.get("speaker_name", ""))
-                        activity_log.append({"type": "tool_call", "tool": block.name, "query": query})
-
-                        result = execute_tool(block.name, block.input)
-
-                        activity_log.append({"type": "tool_result"})
-
-                        tool_results.append({
-                            "type": "tool_result",
-                            "tool_use_id": block.id,
-                            "content": result
-                        })
-
-                messages.append({"role": "assistant", "content": response.content})
-                messages.append({"role": "user", "content": tool_results})
-            else:
-                # Extract questions from response
-                activity_log.append({"type": "generating"})
-
-                final_text = ""
-                for block in response.content:
-                    if hasattr(block, "text"):
-                        final_text += block.text
-
-                try:
-                    json_start = final_text.find("{")
-                    json_end = final_text.rfind("}") + 1
-                    if json_start >= 0 and json_end > json_start:
-                        result = json.loads(final_text[json_start:json_end])
-                        new_questions = result.get("questions", [])
-
-                        # Store in context
-                        for q in new_questions:
-                            context.add_question(
-                                question=q.get("q", ""),
-                                category=q.get("type", ""),
-                                reasoning=q.get("why", "")
-                            )
-                except json.JSONDecodeError:
-                    pass
-
-                break
 
     except Exception as e:
+        logger.error(f"Question generation failed: {e}")
         activity_log.append({"type": "error", "msg": str(e)})
 
     # Combine questions
@@ -281,3 +301,126 @@ Generate 1-3 NEW insightful questions based on the recent content. Be concise.""
         format_questions_html(all_questions),
         format_activity_log(activity_log)
     )
+
+
+def _generate_with_anthropic(client, model, user_message, activity_log, context, max_iterations):
+    """Generate questions using Anthropic API."""
+    messages = [{"role": "user", "content": user_message}]
+    new_questions = []
+    iteration = 0
+
+    while iteration < max_iterations:
+        iteration += 1
+
+        response = client.messages.create(
+            model=model,
+            max_tokens=1024,
+            system=STREAMING_SYSTEM_PROMPT,
+            tools=ANTHROPIC_TOOLS,
+            messages=messages
+        )
+
+        if response.stop_reason == "tool_use":
+            tool_results = []
+            for block in response.content:
+                if block.type == "tool_use":
+                    query = block.input.get("query", block.input.get("speaker_name", ""))
+                    activity_log.append({"type": "tool_call", "tool": block.name, "query": query})
+
+                    result = execute_tool(block.name, block.input)
+                    activity_log.append({"type": "tool_result"})
+
+                    tool_results.append({
+                        "type": "tool_result",
+                        "tool_use_id": block.id,
+                        "content": result
+                    })
+
+            messages.append({"role": "assistant", "content": response.content})
+            messages.append({"role": "user", "content": tool_results})
+        else:
+            activity_log.append({"type": "generating"})
+
+            final_text = ""
+            for block in response.content:
+                if hasattr(block, "text"):
+                    final_text += block.text
+
+            new_questions = _parse_questions(final_text, context)
+            break
+
+    return new_questions
+
+
+def _generate_with_openai(client, model, user_message, activity_log, context, max_iterations):
+    """Generate questions using OpenAI API."""
+    messages = [
+        {"role": "system", "content": STREAMING_SYSTEM_PROMPT},
+        {"role": "user", "content": user_message}
+    ]
+    new_questions = []
+    iteration = 0
+
+    while iteration < max_iterations:
+        iteration += 1
+
+        response = client.chat.completions.create(
+            model=model,
+            max_completion_tokens=1024,
+            tools=OPENAI_TOOLS,
+            messages=messages
+        )
+
+        choice = response.choices[0]
+
+        if choice.finish_reason == "tool_calls" and choice.message.tool_calls:
+            tool_messages = []
+            for tool_call in choice.message.tool_calls:
+                func_name = tool_call.function.name
+                func_args = json.loads(tool_call.function.arguments)
+
+                query = func_args.get("query", func_args.get("speaker_name", ""))
+                activity_log.append({"type": "tool_call", "tool": func_name, "query": query})
+
+                result = execute_tool(func_name, func_args)
+                activity_log.append({"type": "tool_result"})
+
+                tool_messages.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "content": result
+                })
+
+            messages.append(choice.message)
+            messages.extend(tool_messages)
+        else:
+            activity_log.append({"type": "generating"})
+
+            final_text = choice.message.content or ""
+            new_questions = _parse_questions(final_text, context)
+            break
+
+    return new_questions
+
+
+def _parse_questions(text: str, context: ConversationContext) -> list[dict]:
+    """Parse questions from LLM response text."""
+    new_questions = []
+    try:
+        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])
+            new_questions = result.get("questions", [])
+
+            # Store in context
+            for q in new_questions:
+                context.add_question(
+                    question=q.get("q", ""),
+                    category=q.get("type", ""),
+                    reasoning=q.get("why", "")
+                )
+    except json.JSONDecodeError:
+        pass
+
+    return new_questions

uv.lock

@@ -76,8 +76,10 @@ source = { virtual = "." }
 dependencies = [
     { name = "anthropic" },
     { name = "gradio" },
+    { name = "loguru" },
     { name = "openai" },
     { name = "python-dotenv" },
+    { name = "pyyaml" },
     { name = "tavily-python" },
 ]
 
@@ -85,8 +87,10 @@ dependencies = [
 requires-dist = [
     { name = "anthropic", specifier = ">=0.75.0" },
     { name = "gradio", specifier = ">=5.50.0" },
+    { name = "loguru", specifier = ">=0.7.3" },
     { name = "openai", specifier = ">=2.8.1" },
     { name = "python-dotenv", specifier = ">=1.2.1" },
+    { name = "pyyaml", specifier = ">=6.0" },
     { name = "tavily-python", specifier = ">=0.7.13" },
 ]
 
@@ -346,7 +350,7 @@ name = "exceptiongroup"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
@@ -665,6 +669,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2f/9c/6753e6522b8d0ef07d3a3d239426669e984fb0eba15a315cdbc1253904e4/jiter-0.12.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c24e864cb30ab82311c6425655b0cdab0a98c5d973b065c66a3f020740c2324c", size = 346110, upload-time = "2025-11-09T20:49:21.817Z" },
 ]
 
+[[package]]
+name = "loguru"
+version = "0.7.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "win32-setctime", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", hash = "sha256:19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6", size = 63559, upload-time = "2024-12-06T11:20:56.608Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" },
+]
+
 [[package]]
 name = "markdown-it-py"
 version = "4.0.0"
@@ -1902,3 +1919,12 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/68/a1/dcb68430b1d00b698ae7a7e0194433bce4f07ded185f0ee5fb21e2a2e91e/websockets-15.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:cad21560da69f4ce7658ca2cb83138fb4cf695a2ba3e475e0559e05991aa8122", size = 176884, upload-time = "2025-03-05T20:03:27.934Z" },
     { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
 ]
+
+[[package]]
+name = "win32-setctime"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b3/8f/705086c9d734d3b663af0e9bb3d4de6578d08f46b1b101c2442fd9aecaa2/win32_setctime-1.2.0.tar.gz", hash = "sha256:ae1fdf948f5640aae05c511ade119313fb6a30d7eabe25fef9764dca5873c4c0", size = 4867, upload-time = "2024-12-07T15:28:28.314Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/07/c6fe3ad3e685340704d314d765b7912993bcb8dc198f0e7a89382d37974b/win32_setctime-1.2.0-py3-none-any.whl", hash = "sha256:95d644c4e708aba81dc3704a116d8cbc974d70b3bdb8be1d150e36be6e9d1390", size = 4083, upload-time = "2024-12-07T15:28:26.465Z" },
+]