Update demo with latest codebase changes

Sync all files from main sherlock repository including:
- Enhanced app.py with response caching, Google Gemini support, and LangSmith observability
- Updated RAG system with improved vector store handling
- Enhanced agent with better error handling
- Added comprehensive test suite
- Updated documentation and requirements
- Added CITATION.cff and assets structure

Note: Binary assets excluded (will add via Git LFS)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.gitignore

@@ -1,9 +1,34 @@
+# Environment
 .env
+.env.local
+.env.*.local
+
+# Python
 __pycache__/
 *.pyc
+*.pyo
+*.pyd
+.Python
+*.so
 .venv/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
 chroma_db/
 *.db
-.DS_Store
 *.log
 .pytest_cache/
+dist/
+build/
+*.egg-info/

CITATION.cff

@@ -0,0 +1,17 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+title: "Sherlock Project Assistant"
+type: software
+authors:
+  - family-names: "Cajas Ordóñez"
+    given-names: "Sebastián Andrés"
+repository-code: "https://github.com/sebasmos/sherlock"
+url: "https://huggingface.co/spaces/sebasmos/sherlock-project-assistant"
+license: CC-BY-NC-SA-4.0
+keywords:
+  - rag
+  - langchain
+  - langgraph
+  - gradio
+  - chromadb
+  - meeting-assistant

README.md

@@ -1,20 +1,304 @@
----
-title: Sherlock Project Assistant
-emoji: 🔍
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: "4.20.0"
-app_file: app.py
-pinned: false
----
+<div align="center">
+  <img src="assets/logo-transparent-bg.png" alt="Sherlock Logo" width="120">
+  <h1>Sherlock Project Assistant</h1>
+  <p><em>Your intelligent assistant for managing multiple projects through meeting summaries</em></p>
 
-# Sherlock Project Assistant
+  [![License: CC BY-NC-SA 4.0](https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by-nc-sa/4.0/)
+  [![Python Version](https://img.shields.io/badge/python-3.10-blue.svg)](https://github.com/sebasmos/sherlock)
+  [![Hugging Face Space](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Space-blue)](https://huggingface.co/spaces/sebasmos/sherlock-project-assistant)
+</div>
+
+---
 
 An AI-powered project assistant that helps you manage and query your project meetings and documentation.
 
+## Table of Contents
+
+- [Demo](#demo)
+- [Features](#features)
+- [System Architecture](#system-architecture)
+- [Tech Stack](#tech-stack)
+- [Agentic Capabilities](#agentic-capabilities)
+- [Quick Start](#quick-start)
+- [Usage](#usage)
+- [LLM Providers](#llm-providers)
+- [Observability](#observability-langsmith)
+- [Performance Features](#performance-features)
+- [Agent Evaluation](#agent-evaluation)
+- [Testing](#testing)
+- [Project Structure](#project-structure)
+- [Unsorted To-Dos](#unsorted-to-dos)
+
+## Demo
+
+🚀 [Try the live demo here](https://huggingface.co/spaces/sebasmos/sherlock-project-assistant)
+
 ## Features
 
-- RAG-based question answering
-- Meeting notes analysis
-- Project insights and summaries
+- **RAG-powered Q&A** - Ask questions about your projects using ChromaDB vector search
+- **LangGraph AI Agent** - Intelligent query routing for action items, blockers, and status
+- **Multi-project support** - Manage and filter across multiple projects
+- **Meeting structuring** - Upload raw notes and get AI-structured markdown
+- **Action item tracking** - Track open/completed tasks with assignees and deadlines
+- **Blocker & decision tracking** - Surface blockers and key decisions from meetings
+- **Multiple LLM Providers** - Choose between HuggingFace (free) or Google Gemini (paid)
+- **Meeting summary generation** - Get comprehensive summaries with key takeaways
+- **Trend analysis** - Analyze patterns across meetings: recurring topics, blocker trends, progress
+- **LangSmith Observability** - Trace LLM calls, monitor latency, token usage, and errors
+- **Agent Evaluation** - Automated quality testing with keyword matching and latency metrics
+- **Streaming Responses** - See LLM output in real-time as it generates (better UX)
+- **Response Caching** - Faster repeated queries with 5-minute TTL cache (lower API costs)
+- **Export Chat** - Download your conversation history as PDF
+
+## System Architecture
+
+![fig](assets/arch.png)
+
+## Tech Stack
+
+| Category | Technology | Purpose |
+|----------|------------|---------|
+| **Frontend** | Gradio 4.44 | Web UI framework |
+| **LLM Framework** | LangChain | LLM orchestration |
+| **Agent Framework** | LangGraph | State machine for agent routing |
+| **Vector Store** | ChromaDB | Persistent vector storage |
+| **Embeddings** | Sentence Transformers | Text embeddings (all-MiniLM-L6-v2) |
+| **LLM (Free)** | HuggingFace Inference | Llama 3.2 3B Instruct |
+| **LLM (Paid)** | Google Generative AI | Gemini 2.5 Flash Lite |
+| **Data Models** | Pydantic | Data validation |
+| **Testing** | Pytest | Unit and integration tests |
+| **Observability** | LangSmith | LLM tracing and monitoring |
+
+## Agentic Capabilities
+
+| Capability | Description | Trigger Keywords |
+|------------|-------------|------------------|
+| **Query Analysis** | Understands user intent and extracts project context | All queries |
+| **Context Retrieval** | Semantic search across meeting notes | All queries |
+| **Action Item Extraction** | Surfaces open tasks with assignees and deadlines | "action item", "todo", "task", "what's next", "what should" |
+| **Blocker Detection** | Identifies and lists current blockers | "blocker", "issue", "problem", "stuck" |
+| **Decision Tracking** | Retrieves decisions made in meetings | "decision", "decided", "agreed" |
+| **Project Filtering** | Scopes queries to specific projects | Mention project name in query |
+| **Meeting Structuring** | Converts raw notes to formatted markdown | Upload tab |
+
+## Quick Start
+
+### Using uv (recommended)
+
+```bash
+# Clone the repository
+git clone https://github.com/sebasmos/sherlock.git
+cd sherlock
+
+# Create venv and install dependencies
+uv venv --python 3.10
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+uv pip install -r requirements.txt
+
+# Run the app
+python app.py
+```
+
+### Using pip
+
+```bash
+# Clone the repository
+git clone https://github.com/sebasmos/sherlock.git
+cd sherlock
+
+# Create virtual environment (Python 3.10)
+python3.10 -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the app
+python app.py
+```
+
+The app will be available at http://localhost:7860
+
+## Usage
+
+1. Choose your LLM provider and enter your API token
+2. Add your meeting notes to `data/your_project/meetings/*.md`
+3. Start asking questions about your projects
+
+### Meeting Notes Format
+
+```markdown
+# Meeting: Sprint Planning
+Date: 2025-01-15
+Participants: Alice, Bob
+
+## Discussion
+Key points discussed...
+
+## Decisions
+- Decision 1
+- Decision 2
+
+## Action Items
+- [ ] Alice: Implement login by Jan 20
+- [x] Bob: Review PR (completed)
+
+## Blockers
+- Waiting for API credentials
+```
+
+## LLM Providers
+
+### HuggingFace (Free)
+
+| Property | Value |
+|----------|-------|
+| **Model** | Llama 3.2 3B Instruct |
+| **Cost** | Free (rate limited) |
+| **Token URL** | [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens) |
+| **Setup** | 1. Create account → 2. New token → 3. Select "Read" permission |
+
+### Google AI (Paid)
+
+| Property | Value |
+|----------|-------|
+| **Model** | Gemini 2.5 Flash Lite |
+| **Cost** | Pay-per-use |
+| **API Key URL** | [aistudio.google.com/apikey](https://aistudio.google.com/apikey) |
+| **Setup** | 1. Create project → 2. Enable API → 3. Create API key |
+
+## Observability (LangSmith)
+
+Enable LLM tracing and monitoring with [LangSmith](https://smith.langchain.com):
+
+| Property | Value |
+|----------|-------|
+| **Dashboard** | [smith.langchain.com](https://smith.langchain.com) |
+| **Cost** | Free tier available |
+| **Features** | Trace LLM calls, latency, token usage, errors |
+
+### Setup
+
+1. Create account at [smith.langchain.com](https://smith.langchain.com)
+2. Get your API key from Settings
+3. Set environment variables:
+
+```bash
+export LANGCHAIN_API_KEY=your_langsmith_api_key
+export LANGCHAIN_PROJECT=sherlock  # optional, defaults to "sherlock"
+```
+
+Or add to `.env` file:
+
+```
+LANGCHAIN_API_KEY=your_langsmith_api_key
+LANGCHAIN_PROJECT=sherlock
+```
+
+Once configured, all LLM calls are automatically traced and visible in the LangSmith dashboard.
+
+## Performance Features
+
+### Streaming Responses
+
+LLM responses are streamed token-by-token for a better user experience. You see the answer as it's being generated, reducing perceived latency.
+
+### Response Caching
+
+Repeated queries are cached for 5 minutes to reduce API costs and improve response times:
+
+| Property | Value |
+|----------|-------|
+| **TTL** | 5 minutes |
+| **Cache Key** | Query + Project + Provider |
+| **Indicator** | "_⚡ Cached response_" shown for cached answers |
+
+### Chat Export
+
+Export your conversation history as a PDF file:
+
+1. Click the **📥 Export** button in the chat interface
+2. Download the `.pdf` file with all Q&A pairs
+3. Includes project name, timestamp, and nicely formatted conversation
+
+## Agent Evaluation
+
+Automated evaluation measures agent quality across different query types.
+
+| Metric | Value |
+|--------|-------|
+| **Test Cases** | 5 |
+| **Pass Rate** | 100% |
+| **Keyword Match** | 68% |
+| **Avg Latency** | 5.2s |
+| **Avg Response** | 1404 chars |
+
+Run evaluation:
+```bash
+GOOGLE_API_KEY=your_key pytest tests/test_evaluation.py -v -s
+```
+
+## Testing
+
+Run all tests:
+```bash
+HF_TOKEN=your_token GOOGLE_API_KEY=your_key pytest tests/ -v
+```
+
+| File | Description |
+|------|-------------|
+| `test_parsers.py` | Date & action item parsing |
+| `test_rag.py` | RAG indexing & search |
+| `test_app.py` | Upload & project management |
+| `test_integration.py` | LLM provider tests |
+| `test_evaluation.py` | Agent quality metrics |
+
+## Project Structure
+
+```
+sherlock/
+├── app.py                 # Main Gradio application
+├── requirements.txt       # Python dependencies
+├── README.md              # This file
+├── assets/
+│   ├── logo.png           # Project logo
+│   ├── logo-transparent-bg.png
+│   └── favicon/           # Favicon assets
+├── src/
+│   ├── __init__.py
+│   ├── agent.py           # LangGraph AI agent
+│   ├── rag.py             # ChromaDB RAG system
+│   └── parsers.py         # Meeting note parsers
+├── tests/
+│   ├── conftest.py        # Pytest fixtures
+│   ├── test_parsers.py    # Parser tests
+│   ├── test_rag.py        # RAG tests
+│   ├── test_app.py        # Upload meeting & project tests
+│   ├── test_integration.py # LLM provider tests
+│   └── test_evaluation.py # Agent quality evaluation
+└── data/                  # Sample projects included
+    ├── quantum_computing/
+    │   └── meetings/      # Quantum Error Correction research
+    └── covid_prediction/
+        └── meetings/      # COVID-19 Variant Prediction ML project
+```
+
+## Sample Projects
+
+The repository includes two realistic research project examples:
+
+### Quantum Computing (Quantum Error Correction)
+- **Team**: 5 researchers (physics, CS, mathematics)
+- **Topics**: Surface codes, IBM Quantum hardware, decoder algorithms
+- **Example queries**: "What's the decoder latency issue?", "What hardware access do we have?"
+
+### COVID-19 Prediction (Variant Forecasting)
+- **Team**: 5 researchers (epidemiology, ML, bioinformatics)
+- **Topics**: ESM-2 model, GISAID data, CDC collaboration
+- **Example queries**: "What's our model accuracy?", "What are the data quality issues?"
+
+## Unsorted To-Dos
+
+- [ ] Add support for more LLM providers (OpenAI, Anthropic, Ollama)
+- [ ] Implement meeting calendar integration (Google Calendar, Outlook)
+- [ ] Add user authentication for multi-user support

app.py

@@ -4,16 +4,67 @@ Gradio app for AI Project Assistant.
 import gradio as gr
 from pathlib import Path
 import os
+import hashlib
+import time
 from datetime import datetime
 from dotenv import load_dotenv
 from src.rag import ProjectRAG
 from src.agent import ProjectAgent
 from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_core.messages import SystemMessage, HumanMessage
 
 # Load environment variables
 load_dotenv()
 
+
+# Response Cache with TTL
+class ResponseCache:
+    """Simple in-memory cache with time-to-live for LLM responses."""
+
+    def __init__(self, ttl_seconds: int = 300):
+        """Initialize cache with TTL in seconds (default 5 minutes)."""
+        self.cache = {}
+        self.ttl = ttl_seconds
+
+    def _make_key(self, query: str, project: str, provider: str) -> str:
+        """Create a unique cache key."""
+        key_str = f"{query}|{project}|{provider}"
+        return hashlib.md5(key_str.encode()).hexdigest()
+
+    def get(self, query: str, project: str, provider: str) -> str | None:
+        """Get cached response if exists and not expired."""
+        key = self._make_key(query, project, provider)
+        if key in self.cache:
+            entry = self.cache[key]
+            if time.time() - entry["timestamp"] < self.ttl:
+                return entry["response"]
+            else:
+                del self.cache[key]
+        return None
+
+    def set(self, query: str, project: str, provider: str, response: str):
+        """Cache a response."""
+        key = self._make_key(query, project, provider)
+        self.cache[key] = {
+            "response": response,
+            "timestamp": time.time()
+        }
+
+    def clear(self):
+        """Clear all cached responses."""
+        self.cache = {}
+
+
+# Initialize response cache (5 minute TTL)
+response_cache = ResponseCache(ttl_seconds=300)
+
+# LangSmith Observability - Enable tracing if API key is set
+if os.getenv("LANGCHAIN_API_KEY"):
+    os.environ["LANGCHAIN_TRACING_V2"] = "true"
+    os.environ["LANGCHAIN_PROJECT"] = os.getenv("LANGCHAIN_PROJECT", "sherlock")
+    print("LangSmith tracing enabled")
+
 # Global state - Initialize RAG only (not agent)
 rag = None
 
@@ -34,10 +85,13 @@ def initialize_rag():
 # Initialize RAG on module load
 initialize_rag()
 
-def chat(message, history, project_filter, hf_token):
-    """Process chat message."""
-    if not hf_token or hf_token.strip() == "":
-        yield "⚠️ Please enter your HuggingFace token first (get one at https://huggingface.co/settings/tokens)"
+def chat(message, history, project_filter, provider, api_token, use_streaming=True):
+    """Process chat message with streaming and caching support."""
+    if not api_token or api_token.strip() == "":
+        if provider == "HuggingFace (Free)":
+            yield "⚠️ Please enter your HuggingFace token first (get one at https://huggingface.co/settings/tokens)"
+        else:
+            yield "⚠️ Please enter your Google API key first (get one at https://aistudio.google.com/apikey)"
         return
 
     if not rag:
@@ -45,11 +99,22 @@ def chat(message, history, project_filter, hf_token):
         return
 
     try:
-        # Set token in environment for this request
-        os.environ["HF_TOKEN"] = hf_token.strip()
+        # Check cache first
+        project_key = project_filter if project_filter and project_filter != "All Projects" else "all"
+        provider_key = "hf" if provider == "HuggingFace (Free)" else "google"
+        cached_response = response_cache.get(message, project_key, provider_key)
 
-        # Create agent with user's token
-        agent = ProjectAgent(rag)
+        if cached_response:
+            yield f"{cached_response}\n\n_⚡ Cached response_"
+            return
+
+        # Set token in environment for this request
+        if provider == "HuggingFace (Free)":
+            os.environ["HF_TOKEN"] = api_token.strip()
+            agent = ProjectAgent(rag, provider="huggingface")
+        else:
+            os.environ["GOOGLE_API_KEY"] = api_token.strip()
+            agent = ProjectAgent(rag, provider="google")
 
         # Add project context if specified
         if project_filter and project_filter != "All Projects":
@@ -57,10 +122,31 @@ def chat(message, history, project_filter, hf_token):
         else:
             enhanced_prompt = message
 
-        response = agent.query(enhanced_prompt)
-        yield response
+        # Use streaming if enabled
+        if use_streaming:
+            final_response = ""
+            for response_chunk in agent.stream_query(enhanced_prompt):
+                final_response = response_chunk
+                yield response_chunk
+            # Cache the final response
+            response_cache.set(message, project_key, provider_key, final_response)
+        else:
+            response = agent.query(enhanced_prompt)
+            response_cache.set(message, project_key, provider_key, response)
+            yield response
+
     except Exception as e:
-        yield f"❌ Error: {str(e)}\n\nMake sure your HuggingFace token is valid."
+        error_msg = str(e).lower()
+        if "401" in error_msg or "unauthorized" in error_msg or "invalid" in error_msg:
+            yield "❌ **Invalid API Token**\n\nYour token appears to be invalid or expired. Please check:\n- Token is correctly copied (no extra spaces)\n- Token has proper permissions\n- Token is not expired"
+        elif "403" in error_msg or "forbidden" in error_msg:
+            yield "❌ **Access Denied**\n\nYour token doesn't have permission to access this model. Please ensure:\n- HuggingFace: Token has 'Read' permission\n- Google: API is enabled in your project"
+        elif "rate" in error_msg or "quota" in error_msg or "limit" in error_msg:
+            yield "❌ **Rate Limit Exceeded**\n\nYou've hit the API rate limit. Please:\n- Wait a few minutes and try again\n- Consider upgrading to a paid plan"
+        elif "timeout" in error_msg or "timed out" in error_msg:
+            yield "❌ **Request Timeout**\n\nThe request took too long. Please try again."
+        else:
+            yield f"❌ **Error**: {str(e)}\n\nPlease verify your API token is valid and try again."
 
 def get_projects():
     """Get list of projects."""
@@ -70,23 +156,82 @@ def get_projects():
     projects = rag.get_all_projects()
     return ["All Projects"] + projects
 
-def structure_meeting(project_name, meeting_title, meeting_date, participants, meeting_text, hf_token):
+
+def export_chat_to_pdf(chat_history, project):
+    """Export chat history to PDF format and return as downloadable file."""
+    if not chat_history:
+        return None
+
+    from fpdf import FPDF
+
+    # Create PDF
+    pdf = FPDF()
+    pdf.set_auto_page_break(auto=True, margin=15)
+    pdf.add_page()
+
+    # Title
+    pdf.set_font("Helvetica", "B", 16)
+    pdf.cell(0, 10, "Sherlock Chat Export", ln=True, align="C")
+    pdf.ln(5)
+
+    # Metadata
+    pdf.set_font("Helvetica", "", 10)
+    pdf.cell(0, 6, f"Project: {project}", ln=True)
+    pdf.cell(0, 6, f"Exported: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", ln=True)
+    pdf.ln(10)
+
+    # Chat content
+    for i, (user_msg, bot_msg) in enumerate(chat_history, 1):
+        # Question header
+        pdf.set_font("Helvetica", "B", 11)
+        pdf.set_fill_color(230, 230, 250)
+        pdf.multi_cell(0, 8, f"Q{i}: {user_msg}", fill=True)
+        pdf.ln(2)
+
+        # Answer
+        pdf.set_font("Helvetica", "", 10)
+        # Clean up markdown formatting for PDF
+        clean_response = bot_msg.replace("**", "").replace("##", "").replace("- ", "  * ")
+        pdf.multi_cell(0, 6, clean_response)
+        pdf.ln(5)
+
+        # Separator line
+        pdf.set_draw_color(200, 200, 200)
+        pdf.line(10, pdf.get_y(), 200, pdf.get_y())
+        pdf.ln(5)
+
+    # Save to temp file
+    filename = f"sherlock_chat_{project.replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+    filepath = Path("/tmp") / filename
+    pdf.output(str(filepath))
+
+    return str(filepath)
+
+def structure_meeting(project_name, meeting_title, meeting_date, participants, meeting_text, provider, api_token):
     """Structure meeting notes using AI."""
-    if not hf_token or hf_token.strip() == "":
-        return "❌ Please enter your HuggingFace token first"
+    if not api_token or api_token.strip() == "":
+        return "❌ Please enter your API token first"
 
     if not project_name or not meeting_text:
         return "❌ Please provide both project name and meeting notes"
 
     try:
-        # Use HF Inference API with user's token
-        endpoint = HuggingFaceEndpoint(
-            repo_id="meta-llama/Llama-3.2-3B-Instruct",
-            temperature=0.3,
-            max_new_tokens=1024,
-            huggingfacehub_api_token=hf_token.strip()
-        )
-        llm = ChatHuggingFace(llm=endpoint)
+        # Create LLM based on provider
+        if provider == "HuggingFace (Free)":
+            endpoint = HuggingFaceEndpoint(
+                repo_id="meta-llama/Llama-3.2-3B-Instruct",
+                temperature=0.3,
+                max_new_tokens=1024,
+                huggingfacehub_api_token=api_token.strip()
+            )
+            llm = ChatHuggingFace(llm=endpoint)
+        else:
+            llm = ChatGoogleGenerativeAI(
+                model="gemini-2.5-flash-lite",
+                temperature=0.3,
+                google_api_key=api_token.strip(),
+                convert_system_message_to_human=True
+            )
 
         system_prompt = """You are a meeting notes structuring assistant.
 Convert unstructured meeting notes into a well-formatted markdown document with these sections:
@@ -137,7 +282,15 @@ Meeting Details:
         return f"✅ Meeting structured and saved to `{file_path}`\n\n---\n\n{structured_md}"
 
     except Exception as e:
-        return f"❌ Error: {str(e)}"
+        error_msg = str(e).lower()
+        if "401" in error_msg or "unauthorized" in error_msg or "invalid" in error_msg:
+            return "❌ **Invalid API Token**\n\nYour token appears to be invalid or expired."
+        elif "403" in error_msg or "forbidden" in error_msg:
+            return "❌ **Access Denied**\n\nYour token doesn't have permission."
+        elif "rate" in error_msg or "quota" in error_msg or "limit" in error_msg:
+            return "❌ **Rate Limit Exceeded**\n\nPlease wait a few minutes and try again."
+        else:
+            return f"❌ **Error**: {str(e)}\n\nPlease verify your API token."
 
 # Create Gradio interface with custom CSS
 custom_css = """
@@ -183,45 +336,121 @@ custom_css = """
 }
 """
 
-with gr.Blocks(title="Sherlock: AI Project Assistant", theme=gr.themes.Soft(), css=custom_css) as demo:
-    gr.Markdown("""
-    # 🤖 Sherlock: AI Project Assistant
-
-    Your intelligent assistant for managing multiple projects through meeting summaries.
+favicon_head = '''
+<link rel="apple-touch-icon" sizes="57x57" href="/file=assets/favicon/apple-icon-57x57.png">
+<link rel="apple-touch-icon" sizes="60x60" href="/file=assets/favicon/apple-icon-60x60.png">
+<link rel="apple-touch-icon" sizes="72x72" href="/file=assets/favicon/apple-icon-72x72.png">
+<link rel="apple-touch-icon" sizes="76x76" href="/file=assets/favicon/apple-icon-76x76.png">
+<link rel="apple-touch-icon" sizes="114x114" href="/file=assets/favicon/apple-icon-114x114.png">
+<link rel="apple-touch-icon" sizes="120x120" href="/file=assets/favicon/apple-icon-120x120.png">
+<link rel="apple-touch-icon" sizes="144x144" href="/file=assets/favicon/apple-icon-144x144.png">
+<link rel="apple-touch-icon" sizes="152x152" href="/file=assets/favicon/apple-icon-152x152.png">
+<link rel="apple-touch-icon" sizes="180x180" href="/file=assets/favicon/apple-icon-180x180.png">
+<link rel="icon" type="image/png" sizes="192x192" href="/file=assets/favicon/android-icon-192x192.png">
+<link rel="icon" type="image/png" sizes="32x32" href="/file=assets/favicon/favicon-32x32.png">
+<link rel="icon" type="image/png" sizes="96x96" href="/file=assets/favicon/favicon-96x96.png">
+<link rel="icon" type="image/png" sizes="16x16" href="/file=assets/favicon/favicon-16x16.png">
+<meta name="msapplication-TileColor" content="#ffffff">
+<meta name="msapplication-TileImage" content="/file=assets/favicon/ms-icon-144x144.png">
+<meta name="theme-color" content="#ffffff">
+'''
+
+with gr.Blocks(
+    title="Sherlock: AI Project Assistant",
+    theme=gr.themes.Soft(),
+    css=custom_css,
+    head=favicon_head
+) as demo:
+    # Header with logo
+    gr.HTML("""
+    <div style="display: flex; align-items: center; gap: 20px; padding: 10px 0;">
+        <img src="/file=assets/logo-transparent-bg.png" alt="Sherlock Logo" style="width: 80px; height: 80px; object-fit: contain;">
+        <div>
+            <h1 style="margin: 0; font-size: 28px;">Sherlock: AI Project Assistant</h1>
+            <p style="margin: 5px 0 0 0; color: #666;">Your intelligent assistant for managing multiple projects through meeting summaries.</p>
+        </div>
+    </div>
     """)
 
-    # Global HuggingFace Token input
+    # Global Authentication
     gr.Markdown("### 🔑 Authentication")
     with gr.Row():
-        with gr.Column(scale=3):
-            hf_token_global = gr.Textbox(
-                label="HuggingFace Token (Required)",
-                placeholder="Enter your HF token from https://huggingface.co/settings/tokens",
+        with gr.Column(scale=1):
+            provider_dropdown = gr.Dropdown(
+                label="Select Provider",
+                choices=["HuggingFace (Free)", "Google AI (Paid)"],
+                value="HuggingFace (Free)",
+                interactive=True
+            )
+        with gr.Column(scale=2):
+            api_token_global = gr.Textbox(
+                label="API Token (Required)",
+                placeholder="Enter your HuggingFace token",
                 type="password"
             )
         with gr.Column(scale=2):
-            gr.Markdown("""
-            **Get a free token:**
+            provider_info = gr.Markdown("""
+            **HuggingFace (Free):**
             1. Visit [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
-            2. Click "New token"
-            3. Select "Read" permission
-            4. Copy and paste it here
+            2. Click "New token" → Select "Read"
             """)
 
     with gr.Row():
         submit_token_btn = gr.Button("Submit Token", variant="primary")
         token_status = gr.Markdown("", elem_classes="token-status")
 
-    def validate_token(token):
-        if token and token.strip():
-            return '<div class="token-accepted">✅ Token Accepted</div>'
+    def update_provider_ui(provider):
+        """Update UI based on selected provider. Also clears token and status."""
+        if provider == "HuggingFace (Free)":
+            return (
+                gr.update(placeholder="Enter your HuggingFace token", value=""),
+                """**HuggingFace (Free):**
+            1. Visit [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
+            2. Click "New token" → Select "Read"
+            """,
+                ""  # Clear status
+            )
+        else:
+            return (
+                gr.update(placeholder="Enter your Google API key", value=""),
+                """**Google AI (Paid):**
+            1. Visit [aistudio.google.com/apikey](https://aistudio.google.com/apikey)
+            2. Create an API key
+            """,
+                ""  # Clear status
+            )
+
+    provider_dropdown.change(
+        fn=update_provider_ui,
+        inputs=[provider_dropdown],
+        outputs=[api_token_global, provider_info, token_status]
+    )
+
+    def validate_token(token, provider):
+        """Validate token - simplified without heavy API call."""
+        if not token or not token.strip():
+            return '<div style="background-color: #fee2e2; color: #991b1b; padding: 10px; border-radius: 5px;">❌ Please enter a token</div>', ""
+
+        token_value = token.strip()
+
+        # Simple format validation
+        if provider == "HuggingFace (Free)":
+            # HF tokens start with "hf_"
+            if token_value.startswith("hf_") and len(token_value) > 10:
+                return '<div class="token-accepted">✅ Token format valid - will verify on first query</div>', token_value
+            else:
+                return '<div style="background-color: #fee2e2; color: #991b1b; padding: 10px; border-radius: 5px;">❌ Invalid HuggingFace token format (should start with hf_)</div>', ""
         else:
-            return '<div style="background-color: #fee2e2; color: #991b1b; padding: 10px; border-radius: 5px;">❌ Please enter a valid token</div>'
+            # Google API keys are typically 39 chars
+            if len(token_value) >= 30:
+                return '<div class="token-accepted">✅ API key format valid - will verify on first query</div>', token_value
+            else:
+                return '<div style="background-color: #fee2e2; color: #991b1b; padding: 10px; border-radius: 5px;">❌ Invalid Google API key format</div>', ""
 
     submit_token_btn.click(
         fn=validate_token,
-        inputs=[hf_token_global],
-        outputs=[token_status]
+        inputs=[api_token_global, provider_dropdown],
+        outputs=[token_status, api_token_global]
     )
 
     # Main tabs
@@ -230,6 +459,10 @@ with gr.Blocks(title="Sherlock: AI Project Assistant", theme=gr.themes.Soft(), c
         with gr.Tab("💬 Chat"):
             gr.Markdown("### Ask questions about your projects")
 
+            # State for per-project chat histories
+            chat_histories = gr.State({})  # {project_name: [(user_msg, bot_msg), ...]}
+            current_project = gr.State("All Projects")
+
             # Project selection dropdown
             project_dropdown = gr.Dropdown(
                 label="Select Project",
@@ -267,41 +500,106 @@ with gr.Blocks(title="Sherlock: AI Project Assistant", theme=gr.themes.Soft(), c
                     msg = gr.Textbox(
                         label="Your Message",
                         placeholder="What are the open action items?",
-                        lines=2,
+                        lines=1,
                         show_label=False
                     )
 
                     with gr.Row():
                         submit_btn = gr.Button("Send", variant="primary", scale=1)
                         clear_btn = gr.Button("Clear", scale=1)
+                        export_btn = gr.Button("📥 Export", scale=1)
+
+                    export_file = gr.File(label="Download", visible=False)
+
+            def respond(message, chat_history, histories, project, provider, token):
+                if not message:
+                    yield chat_history, "", histories
+                    return
 
-            def respond(message, chat_history, project, token):
+                # Add user message with empty bot response placeholder
+                chat_history = chat_history + [(message, "")]
+
+                # Stream bot response
+                for response_chunk in chat(message, chat_history, project, provider, token):
+                    # Update the last message with streaming response
+                    chat_history[-1] = (message, response_chunk)
+                    yield chat_history, "", histories
+
+                # Save final history to per-project histories
+                histories[project] = chat_history.copy()
+                yield chat_history, "", histories
+                return
+
+            def respond_non_streaming(message, chat_history, histories, project, provider, token):
+                """Non-streaming version for fallback."""
                 if not message:
-                    return chat_history, ""
+                    return chat_history, "", histories
 
                 # Get bot response
                 bot_message = ""
-                for response_chunk in chat(message, chat_history, project, token):
+                for response_chunk in chat(message, chat_history, project, provider, token, use_streaming=False):
                     bot_message = response_chunk
 
                 # Add to history as tuple
                 chat_history.append((message, bot_message))
 
-                return chat_history, ""
+                # Save to per-project histories
+                histories[project] = chat_history.copy()
+
+                return chat_history, "", histories
+
+            def switch_project(new_project, current_chat, histories, old_project):
+                # Save current chat to old project
+                if current_chat:
+                    histories[old_project] = current_chat.copy()
+
+                # Load chat history for new project (or empty if none)
+                new_chat = histories.get(new_project, [])
+
+                return new_chat, histories, new_project
+
+            def clear_chat(project, histories):
+                # Clear current project's history
+                histories[project] = []
+                return [], histories
 
             submit_btn.click(
                 fn=respond,
-                inputs=[msg, chatbot, project_dropdown, hf_token_global],
-                outputs=[chatbot, msg]
+                inputs=[msg, chatbot, chat_histories, project_dropdown, provider_dropdown, api_token_global],
+                outputs=[chatbot, msg, chat_histories]
             )
 
             msg.submit(
                 fn=respond,
-                inputs=[msg, chatbot, project_dropdown, hf_token_global],
-                outputs=[chatbot, msg]
+                inputs=[msg, chatbot, chat_histories, project_dropdown, provider_dropdown, api_token_global],
+                outputs=[chatbot, msg, chat_histories]
+            )
+
+            clear_btn.click(
+                fn=clear_chat,
+                inputs=[project_dropdown, chat_histories],
+                outputs=[chatbot, chat_histories]
+            )
+
+            def handle_export(chat_history, project):
+                """Handle export button click."""
+                if not chat_history:
+                    return gr.update(visible=False, value=None)
+                filepath = export_chat_to_pdf(chat_history, project)
+                return gr.update(visible=True, value=filepath)
+
+            export_btn.click(
+                fn=handle_export,
+                inputs=[chatbot, project_dropdown],
+                outputs=[export_file]
             )
 
-            clear_btn.click(fn=lambda: [], outputs=chatbot)
+            # Switch project: save current, load new
+            project_dropdown.change(
+                fn=switch_project,
+                inputs=[project_dropdown, chatbot, chat_histories, current_project],
+                outputs=[chatbot, chat_histories, current_project]
+            )
 
         # Upload Meeting tab
         with gr.Tab("📤 Upload Meeting"):
@@ -370,19 +668,235 @@ Charlie is blocked waiting for API credentials.""",
             structure_btn = gr.Button("🤖 Structure Meeting with AI", variant="primary")
             structure_output = gr.Markdown(label="Structured Output")
 
-            def structure_meeting_wrapper(mode, existing_proj, new_proj, title, date, participants, text, token):
+            def structure_meeting_wrapper(mode, existing_proj, new_proj, title, date, participants, text, provider, token):
                 """Wrapper to handle both project modes."""
+                global rag
                 # Determine which project name to use
                 project_name = existing_proj if mode == "Use Existing Project" else new_proj
-                return structure_meeting(project_name, title, date, participants, text, token)
+                result = structure_meeting(project_name, title, date, participants, text, provider, token)
+
+                # If successful, re-index RAG and update project lists
+                if result.startswith("✅"):
+                    # Re-initialize RAG to pick up new project/meeting
+                    initialize_rag()
+
+                    # Get updated project list
+                    updated_projects = get_projects()
+                    updated_existing = updated_projects[1:]  # Exclude "All Projects"
+
+                    return (
+                        result,
+                        gr.update(choices=updated_projects, value="All Projects"),
+                        gr.update(choices=updated_existing)
+                    )
+
+                return result, gr.update(), gr.update()
 
             structure_btn.click(
                 fn=structure_meeting_wrapper,
-                inputs=[project_mode, existing_project, new_project, upload_title, upload_date, upload_participants, upload_text, hf_token_global],
-                outputs=structure_output
+                inputs=[project_mode, existing_project, new_project, upload_title, upload_date, upload_participants, upload_text, provider_dropdown, api_token_global],
+                outputs=[structure_output, project_dropdown, existing_project]
+            )
+
+        # Insights tab
+        with gr.Tab("📊 Insights"):
+            gr.Markdown("### Project Insights & Analytics")
+
+            insights_project = gr.Dropdown(
+                label="Select Project",
+                choices=get_projects()[1:],  # Exclude "All Projects"
+                interactive=True
+            )
+
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("#### 📝 Meeting Summary")
+                    gr.Markdown("Generate a comprehensive summary with key takeaways from all meetings.")
+                    summary_btn = gr.Button("Generate Summary", variant="primary")
+                    summary_output = gr.Markdown(label="Summary")
+
+                with gr.Column():
+                    gr.Markdown("#### 📈 Trend Analysis")
+                    gr.Markdown("Analyze patterns across meetings: recurring topics, blocker trends, action item progress.")
+                    trends_btn = gr.Button("Analyze Trends", variant="primary")
+                    trends_output = gr.Markdown(label="Trends")
+
+            def generate_summary(project, provider, token):
+                """Generate a summary with key takeaways for a project."""
+                if not token or token.strip() == "":
+                    return "❌ Please enter your API token first"
+
+                if not project:
+                    return "❌ Please select a project"
+
+                if not rag:
+                    return "❌ System not initialized"
+
+                try:
+                    # Get all meeting content for the project
+                    meetings = rag.get_project_documents(project)
+                    if not meetings:
+                        return f"❌ No meetings found for project: {project}"
+
+                    meeting_content = "\n\n---\n\n".join([doc.page_content for doc in meetings])
+
+                    # Create LLM
+                    if provider == "HuggingFace (Free)":
+                        endpoint = HuggingFaceEndpoint(
+                            repo_id="meta-llama/Llama-3.2-3B-Instruct",
+                            temperature=0.3,
+                            max_new_tokens=1500,
+                            huggingfacehub_api_token=token.strip()
+                        )
+                        llm = ChatHuggingFace(llm=endpoint)
+                    else:
+                        llm = ChatGoogleGenerativeAI(
+                            model="gemini-2.5-flash-lite",
+                            temperature=0.3,
+                            google_api_key=token.strip()
+                        )
+
+                    prompt = f"""Analyze these meeting notes and provide a comprehensive project summary with key takeaways.
+
+Meeting Notes:
+{meeting_content}
+
+Provide:
+## Project Summary
+A brief overview of the project status and progress.
+
+## Key Takeaways
+- List the most important points and insights
+- Highlight critical decisions made
+- Note significant achievements
+
+## Open Items
+- List pending action items
+- Note unresolved blockers
+
+## Recommendations
+- Suggest next steps based on the meeting content
+"""
+
+                    messages = [HumanMessage(content=prompt)]
+                    response = llm.invoke(messages)
+                    return response.content
+
+                except Exception as e:
+                    return f"❌ Error: {str(e)}"
+
+            def analyze_trends(project, provider, token):
+                """Analyze trends across meetings for a project."""
+                if not token or token.strip() == "":
+                    return "❌ Please enter your API token first"
+
+                if not project:
+                    return "❌ Please select a project"
+
+                if not rag:
+                    return "❌ System not initialized"
+
+                try:
+                    # Get all meeting content for the project
+                    meetings = rag.get_project_documents(project)
+                    if not meetings:
+                        return f"❌ No meetings found for project: {project}"
+
+                    if len(meetings) < 2:
+                        return "⚠️ Need at least 2 meetings to analyze trends"
+
+                    meeting_content = "\n\n---\n\n".join([doc.page_content for doc in meetings])
+
+                    # Create LLM
+                    if provider == "HuggingFace (Free)":
+                        endpoint = HuggingFaceEndpoint(
+                            repo_id="meta-llama/Llama-3.2-3B-Instruct",
+                            temperature=0.3,
+                            max_new_tokens=1500,
+                            huggingfacehub_api_token=token.strip()
+                        )
+                        llm = ChatHuggingFace(llm=endpoint)
+                    else:
+                        llm = ChatGoogleGenerativeAI(
+                            model="gemini-2.5-flash-lite",
+                            temperature=0.3,
+                            google_api_key=token.strip()
+                        )
+
+                    prompt = f"""Analyze these meeting notes chronologically and identify trends and patterns.
+
+Meeting Notes:
+{meeting_content}
+
+Provide a trend analysis with:
+
+## Topic Evolution
+How have discussion topics evolved across meetings?
+
+## Recurring Themes
+What topics or issues keep coming up repeatedly?
+
+## Blocker Patterns
+- Are there recurring blockers?
+- How quickly are blockers typically resolved?
+- Are there systemic issues causing repeated blockers?
+
+## Action Item Trends
+- Are action items being completed on time?
+- Who are the most frequently assigned team members?
+- Are there patterns in delayed items?
+
+## Team Dynamics
+- Who are the key contributors?
+- Are there communication patterns worth noting?
+
+## Progress Trajectory
+Is the project on track? Accelerating or slowing down?
+"""
+
+                    messages = [HumanMessage(content=prompt)]
+                    response = llm.invoke(messages)
+                    return response.content
+
+                except Exception as e:
+                    return f"❌ Error: {str(e)}"
+
+            summary_btn.click(
+                fn=generate_summary,
+                inputs=[insights_project, provider_dropdown, api_token_global],
+                outputs=summary_output
+            )
+
+            trends_btn.click(
+                fn=analyze_trends,
+                inputs=[insights_project, provider_dropdown, api_token_global],
+                outputs=trends_output
             )
 
 
 # Launch
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    import socket
+
+    def find_free_port(start_port=7860, max_attempts=10):
+        """Find an available port starting from start_port."""
+        for port in range(start_port, start_port + max_attempts):
+            try:
+                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                    s.bind(('', port))
+                    return port
+            except OSError:
+                continue
+        return None
+
+    port = find_free_port()
+    if port:
+        print(f"Starting on port {port}")
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=port,
+            favicon_path="assets/favicon/favicon.ico",
+            allowed_paths=["assets/"]
+        )
+    else:
+        print("Error: Could not find an available port in range 7860-7869")

assets/favicon/browserconfig.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<browserconfig><msapplication><tile><square70x70logo src="/ms-icon-70x70.png"/><square150x150logo src="/ms-icon-150x150.png"/><square310x310logo src="/ms-icon-310x310.png"/><TileColor>#ffffff</TileColor></tile></msapplication></browserconfig>

assets/favicon/manifest.json

@@ -0,0 +1,41 @@
+{
+ "name": "App",
+ "icons": [
+  {
+   "src": "\/android-icon-36x36.png",
+   "sizes": "36x36",
+   "type": "image\/png",
+   "density": "0.75"
+  },
+  {
+   "src": "\/android-icon-48x48.png",
+   "sizes": "48x48",
+   "type": "image\/png",
+   "density": "1.0"
+  },
+  {
+   "src": "\/android-icon-72x72.png",
+   "sizes": "72x72",
+   "type": "image\/png",
+   "density": "1.5"
+  },
+  {
+   "src": "\/android-icon-96x96.png",
+   "sizes": "96x96",
+   "type": "image\/png",
+   "density": "2.0"
+  },
+  {
+   "src": "\/android-icon-144x144.png",
+   "sizes": "144x144",
+   "type": "image\/png",
+   "density": "3.0"
+  },
+  {
+   "src": "\/android-icon-192x192.png",
+   "sizes": "192x192",
+   "type": "image\/png",
+   "density": "4.0"
+  }
+ ]
+}

data/covid_prediction/meetings/2025-01-10-project-initiation.md

@@ -0,0 +1,33 @@
+# Meeting: COVID-19 Variant Prediction Model - Project Initiation
+Date: 2025-01-10
+Participants: Dr. Amanda Foster, Kevin Liu, Dr. Rachel Okonkwo, Michael Santos, Dr. Yuki Tanaka
+
+## Discussion
+The team convened to launch the COVID-19 variant prediction project in collaboration with the CDC and WHO. Dr. Foster outlined the project scope: develop a machine learning system to predict emerging SARS-CoV-2 variants with pandemic potential based on genomic surveillance data.
+
+We will analyze sequences from GISAID (Global Initiative on Sharing All Influenza Data) which currently contains over 15 million SARS-CoV-2 sequences. The model will focus on spike protein mutations and their predicted impact on transmissibility and immune escape.
+
+Kevin presented the proposed architecture: a transformer-based model fine-tuned on protein sequences (building on ESM-2 from Meta) combined with an epidemiological compartmental model (SEIR variant) for transmission dynamics.
+
+Dr. Okonkwo discussed data preprocessing requirements. We need to handle significant class imbalance - variants of concern (VOC) represent less than 0.1% of all sequences. She proposed using focal loss and synthetic minority oversampling.
+
+Dr. Tanaka presented the clinical validation strategy using retrospective analysis of Delta and Omicron emergence patterns.
+
+## Decisions
+- Use ESM-2 (650M parameter version) as the foundation model
+- Implement SEIR compartmental model for transmission prediction
+- Focus on spike protein receptor binding domain (RBD) mutations
+- Deploy on Google Cloud Platform using Vertex AI
+- Weekly data refresh from GISAID every Monday
+
+## Action Items
+- [ ] Dr. Foster: Establish data sharing agreement with GISAID by 2025-01-17
+- [ ] Kevin Liu: Set up GCP project and Vertex AI pipelines by 2025-01-14
+- [ ] Dr. Okonkwo: Implement data preprocessing pipeline for FASTA files by 2025-01-20
+- [ ] Michael Santos: Create feature engineering module for mutation analysis by 2025-01-22
+- [ ] Dr. Tanaka: Prepare validation dataset with labeled VOC sequences by 2025-01-25
+
+## Blockers
+- GISAID data access requires institutional agreement (legal review in progress)
+- GPU quota on GCP needs to be increased for A100 instances
+- Need IRB approval for any human mobility data integration

data/covid_prediction/meetings/2025-01-17-model-architecture-review.md

@@ -0,0 +1,41 @@
+# Meeting: Model Architecture Review and Data Pipeline Update
+Date: 2025-01-17
+Participants: Dr. Amanda Foster, Kevin Liu, Dr. Rachel Okonkwo, Michael Santos
+
+## Discussion
+Kevin demonstrated the GCP infrastructure setup. We have a Vertex AI training pipeline configured with 4x A100 GPUs for distributed training. The estimated training time for the full ESM-2 fine-tuning is approximately 72 hours.
+
+Dr. Okonkwo presented the data preprocessing pipeline:
+- Successfully downloaded 2.3M sequences from GISAID (last 6 months)
+- Implemented quality filtering: removed sequences with >5% ambiguous bases
+- Created spike protein extraction module achieving 99.7% extraction rate
+- Identified 847 unique RBD mutations across the dataset
+
+Michael showed the mutation feature engineering module. Key features include:
+- Mutation frequency trajectory over time
+- Predicted binding affinity changes (using PyRosetta)
+- Phylogenetic distance from reference strain (Wuhan-Hu-1)
+- Geographic spread velocity
+
+The team discussed the model evaluation strategy. We agreed to use a temporal split: train on pre-October 2024 data and validate on October 2024 - January 2025 to test prediction of recent variants.
+
+Dr. Foster shared that the GISAID data agreement was approved. However, we discovered that mutation annotations need to be recomputed due to reference sequence updates.
+
+## Decisions
+- Use temporal split for evaluation (train: pre-Oct 2024, test: Oct 2024-Jan 2025)
+- Implement early stopping based on validation AUC-ROC
+- Add uncertainty quantification using Monte Carlo dropout
+- Create dashboard using Streamlit for weekly variant monitoring
+
+## Action Items
+- [ ] Kevin Liu: Implement distributed training script with PyTorch Lightning by 2025-01-24
+- [ ] Dr. Okonkwo: Recompute mutation annotations with updated reference by 2025-01-21
+- [ ] Michael Santos: Integrate PyRosetta binding affinity predictions by 2025-01-28
+- [ ] Dr. Foster: Draft manuscript outline for Nature Communications by 2025-01-30
+- [x] Dr. Foster: Establish data sharing agreement with GISAID (completed)
+- [x] Kevin Liu: Set up GCP project and Vertex AI pipelines (completed)
+
+## Blockers
+- PyRosetta license renewal pending - temporary workaround using AlphaFold2 structures
+- GISAID API rate limiting affecting data refresh frequency
+- Need additional compute budget for hyperparameter optimization (~$5K)

data/covid_prediction/meetings/2025-01-24-training-results.md

@@ -0,0 +1,50 @@
+# Meeting: Initial Training Results and Variant Detection Analysis
+Date: 2025-01-24
+Participants: Dr. Amanda Foster, Kevin Liu, Dr. Rachel Okonkwo, Michael Santos, Dr. Yuki Tanaka
+
+## Discussion
+Kevin presented the first complete training run results. The ESM-2 fine-tuned model achieved:
+- AUC-ROC: 0.89 on validation set (Oct 2024 - Jan 2025 sequences)
+- Precision@100: 0.72 (72 of top 100 predicted high-risk mutations appeared in VOCs)
+- Recall for Omicron BA.2.86 (Pirola): Model correctly flagged 85% of key mutations
+
+Dr. Tanaka performed the retrospective validation:
+- Model would have detected Delta variant mutations 6 weeks before WHO designation
+- Omicron BA.1 detection: 4 weeks before designation
+- JN.1 variant: 3 weeks early warning
+
+Dr. Okonkwo showed concerning data quality issues:
+- 12% of sequences have incomplete metadata (location, collection date)
+- Significant reporting delays from some countries (up to 8 weeks)
+- Batch effects visible between sequencing centers
+
+Michael demonstrated the feature importance analysis:
+- ACE2 binding affinity change: most predictive feature (SHAP value: 0.34)
+- Geographic spread velocity: second most important (0.28)
+- Phylogenetic distance: moderate importance (0.15)
+
+The team discussed deployment strategy. We agreed to implement a tiered alert system:
+- Red: >90% confidence, immediate notification
+- Yellow: 70-90% confidence, weekly digest
+- Green: <70% confidence, monitoring only
+
+## Decisions
+- Deploy tiered alert system to CDC dashboard next week
+- Implement data quality filters (reject sequences with >3 missing metadata fields)
+- Add model calibration using temperature scaling
+- Create public API for academic researchers (rate-limited)
+- Submit preliminary results to WHO surveillance network
+
+## Action Items
+- [ ] Kevin Liu: Deploy model to production on Vertex AI by 2025-01-28
+- [ ] Dr. Okonkwo: Implement data quality scoring system by 2025-01-31
+- [ ] Michael Santos: Build Streamlit dashboard for variant monitoring by 2025-02-03
+- [ ] Dr. Tanaka: Write validation methodology section for paper by 2025-02-05
+- [ ] Dr. Foster: Present preliminary results at CDC meeting on 2025-02-10
+- [x] Kevin Liu: Implement distributed training script with PyTorch Lightning (completed)
+- [x] Dr. Okonkwo: Recompute mutation annotations with updated reference (completed)
+
+## Blockers
+- Model inference cost higher than budgeted (~$2K/month) - exploring model distillation
+- CDC requires FISMA compliance for dashboard - security review scheduled
+- Some team members need clearance for WHO data access

data/quantum_computing/meetings/2025-01-08-project-kickoff.md

@@ -0,0 +1,31 @@
+# Meeting: Quantum Error Correction Project Kickoff
+Date: 2025-01-08
+Participants: Dr. Sarah Chen, Marcus Webb, Dr. Priya Patel, James Rodriguez, Dr. Elena Volkov
+
+## Discussion
+The team assembled to initiate the Quantum Error Correction (QEC) research project funded by the National Science Foundation. Dr. Chen outlined the 18-month timeline and key milestones.
+
+The primary objective is to develop a novel surface code implementation that reduces logical error rates by at least 10x compared to current approaches. We discussed the theoretical framework based on topological codes and the experimental validation strategy using IBM's 127-qubit Eagle processor.
+
+Marcus presented the current state of our quantum simulation infrastructure. We have access to AWS Braket for cloud simulations and a local 20-qubit simulator. Dr. Patel raised concerns about the coherence time limitations in current hardware.
+
+Dr. Volkov discussed the mathematical foundations and proposed using stabilizer formalism for the initial prototype. James will lead the software engineering effort using Qiskit and Cirq frameworks.
+
+## Decisions
+- Adopt surface code architecture as the primary approach
+- Use IBM Quantum for experimental validation (127-qubit Eagle processor)
+- Implement simulation pipeline using Qiskit with Cirq as backup
+- Weekly sync meetings on Wednesdays at 2 PM EST
+- Use Slack channel #quantum-qec for daily communication
+
+## Action Items
+- [ ] Dr. Chen: Submit IRB protocol for computational resource allocation by 2025-01-15
+- [ ] Marcus Webb: Set up AWS Braket development environment by 2025-01-12
+- [ ] Dr. Patel: Literature review on recent surface code implementations by 2025-01-20
+- [ ] James Rodriguez: Create GitHub repository and CI/CD pipeline by 2025-01-10
+- [ ] Dr. Volkov: Draft mathematical specification document by 2025-01-18
+
+## Blockers
+- Waiting for IBM Quantum Network access approval (submitted 2024-12-20)
+- Need additional GPU compute allocation for tensor network simulations
+- Hardware calibration data from IBM not yet available for Eagle processor

data/quantum_computing/meetings/2025-01-15-week2-technical-review.md

@@ -0,0 +1,33 @@
+# Meeting: Week 2 Technical Review - Surface Code Implementation
+Date: 2025-01-15
+Participants: Dr. Sarah Chen, Marcus Webb, Dr. Priya Patel, James Rodriguez
+
+## Discussion
+Marcus demonstrated the initial AWS Braket setup. We successfully ran benchmark circuits on the SV1 simulator with up to 34 qubits. Performance metrics show approximately 10^6 circuit evaluations per hour, which meets our simulation requirements.
+
+James presented the repository structure and the initial Qiskit implementation of the distance-3 surface code. The current implementation includes syndrome extraction circuits and basic decoding using minimum weight perfect matching (MWPM).
+
+Dr. Patel shared findings from the literature review:
+- Google's 2023 paper achieved logical error rate of 2.9% with distance-5 code
+- IBM's recent work on heavy-hex lattice shows promise for our approach
+- New decoder architectures using neural networks show 15% improvement over MWPM
+
+The team discussed the trade-off between code distance and physical qubit requirements. For distance-5, we need 49 physical qubits, leaving headroom on the 127-qubit processor.
+
+## Decisions
+- Target distance-5 surface code for initial experiments
+- Implement both MWPM and neural network decoder for comparison
+- Use heavy-hex lattice connectivity constraint in simulations
+- Schedule bi-weekly demos for stakeholders
+
+## Action Items
+- [ ] Marcus Webb: Implement distance-5 surface code in Qiskit by 2025-01-25
+- [ ] James Rodriguez: Integrate MWPM decoder from PyMatching library by 2025-01-22
+- [ ] Dr. Patel: Design neural network decoder architecture by 2025-01-28
+- [ ] Dr. Chen: Prepare Q1 progress report for NSF by 2025-01-30
+- [x] James Rodriguez: Create GitHub repository and CI/CD pipeline (completed)
+
+## Blockers
+- IBM Quantum Network access still pending - escalated to program manager
+- PyMatching library has compatibility issues with latest Qiskit version
+- Need clarification on data sharing agreement for publishing results

data/quantum_computing/meetings/2025-01-22-decoder-benchmark.md

@@ -0,0 +1,38 @@
+# Meeting: Decoder Benchmarking Results and Hardware Access Update
+Date: 2025-01-22
+Participants: Dr. Sarah Chen, Marcus Webb, Dr. Priya Patel, James Rodriguez, Dr. Elena Volkov
+
+## Discussion
+Great news - IBM Quantum Network access was approved! We now have priority access to the 127-qubit Eagle processor. Dr. Chen demonstrated the initial calibration runs showing T1 times averaging 120μs and T2 times of 80μs across the device.
+
+James presented the decoder benchmarking results:
+- MWPM decoder (PyMatching): 94.2% accuracy at p=0.1% physical error rate
+- Union-Find decoder: 93.8% accuracy, but 3x faster execution
+- Neural network decoder (preliminary): 95.1% accuracy, training ongoing
+
+Marcus showed the distance-5 surface code simulation results. With 49 physical qubits, we achieved a logical error rate of 0.8% at p=0.1% physical error rate. This is competitive with published results.
+
+Dr. Volkov proposed an optimization to the syndrome extraction circuit that reduces depth by 15%. This could significantly improve performance on noisy hardware.
+
+Dr. Patel raised concerns about the decoder latency requirements for real-time feedback. The neural network decoder currently takes 50ms per decode cycle, which exceeds the 10ms requirement.
+
+## Decisions
+- Use Union-Find decoder for real-time experiments (meets latency requirements)
+- Continue neural network decoder development for offline analysis
+- Implement Dr. Volkov's circuit optimization immediately
+- Schedule first hardware experiment for February 5th
+- Target submission to Physical Review Letters by March
+
+## Action Items
+- [ ] Marcus Webb: Implement Volkov's circuit optimization by 2025-01-26
+- [ ] James Rodriguez: Optimize neural network decoder inference time by 2025-01-29
+- [ ] Dr. Patel: Prepare hardware experiment protocol by 2025-02-01
+- [ ] Dr. Volkov: Theoretical analysis of optimized circuit fidelity by 2025-01-30
+- [ ] Dr. Chen: Book IBM Quantum time slots for February experiments by 2025-01-25
+- [x] Marcus Webb: Implement distance-5 surface code in Qiskit (completed)
+- [x] James Rodriguez: Integrate MWPM decoder from PyMatching library (completed)
+
+## Blockers
+- Neural network decoder latency too high for real-time use - exploring FPGA implementation
+- IBM device calibration drifts daily - need to implement recalibration protocol
+- Publication embargo from IBM on hardware results until March 1st

data/quantum_computing/meetings/2025-12-01-test.md

@@ -0,0 +1,18 @@
+Here are the structured meeting notes in markdown format:
+
+# Meeting: test
+Date: 2025-12-01
+Participants: alice, bob
+
+## Discussion (key points discussed)
+- test
+
+## Decisions (decisions made)
+- None mentioned
+
+## Action Items (as checkboxes with assignee and deadline if mentioned)
+- [ ] alice: test (no deadline mentioned)
+- [ ] bob: test (no deadline mentioned)
+
+## Blockers (any blockers or issues raised)
+- None mentioned

requirements.txt

@@ -1,8 +1,9 @@
 # Core dependencies
-gradio==4.20.0
+gradio==4.44.1
 langchain>=0.3.0
 langchain-community>=0.0.10
 langchain-huggingface>=0.1.0
+langchain-google-genai>=2.0.0
 langchain-text-splitters>=0.3.0
 
 # Vector store and embeddings
@@ -13,13 +14,23 @@ huggingface-hub>=0.20.0
 # Agent framework
 langgraph>=0.0.20
 
+# Observability
+langsmith>=0.1.0
+
 # Document processing
 python-dotenv>=1.0.0
-pydantic>=2.5.3
+pydantic>=2.5.3,<2.11.0
 
 # Utilities
 pyyaml>=6.0.0
 python-dateutil>=2.8.2
 
 # For HF Inference
-transformers>=4.30.0
+transformers>=4.30.0
+
+# Testing
+pytest>=7.0.0
+pytest-cov>=4.0.0
+
+# PDF Export
+fpdf2>=2.7.0

src/agent.py

@@ -6,6 +6,7 @@ import operator
 import os
 from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, SystemMessage
 from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+from langchain_google_genai import ChatGoogleGenerativeAI
 from langgraph.graph import StateGraph, END
 from src.rag import ProjectRAG
 
@@ -23,20 +24,44 @@ class AgentState(TypedDict):
 
 class ProjectAgent:
     """AI Agent for project management queries."""
-    
-    def __init__(self, rag: ProjectRAG, model_name: str = "meta-llama/Llama-3.2-3B-Instruct"):
-        """Initialize the agent."""
+
+    def __init__(self, rag: ProjectRAG, provider: str = "huggingface", model_name: str = None):
+        """Initialize the agent.
+
+        Args:
+            rag: ProjectRAG instance for retrieval
+            provider: "huggingface" (free) or "google" (paid)
+            model_name: Optional model name override
+        """
         self.rag = rag
-        # Use HF Inference API (free tier)
-        # HF Spaces provides token as HF_TOKEN or HUGGING_FACE_HUB_TOKEN
-        hf_token = os.getenv("HF_TOKEN") or os.getenv("HUGGING_FACE_HUB_TOKEN")
-        llm = HuggingFaceEndpoint(
-            repo_id=model_name,
-            temperature=0.1,
-            max_new_tokens=512,
-            huggingfacehub_api_token=hf_token
-        )
-        self.llm = ChatHuggingFace(llm=llm)
+        self.provider = provider
+
+        if provider == "google":
+            # Use Google Gemini API (paid)
+            google_api_key = os.getenv("GOOGLE_API_KEY")
+            if not google_api_key:
+                raise ValueError("GOOGLE_API_KEY environment variable not set")
+            self.llm = ChatGoogleGenerativeAI(
+                model=model_name or "gemini-2.5-flash-lite",
+                temperature=0.1,
+                google_api_key=google_api_key,
+                timeout=60,  # 60 second timeout
+                convert_system_message_to_human=True  # Better compatibility
+            )
+        else:
+            # Use HF Inference API (free tier)
+            hf_token = os.getenv("HF_TOKEN") or os.getenv("HUGGING_FACE_HUB_TOKEN")
+            if not hf_token:
+                raise ValueError("HF_TOKEN environment variable not set")
+            llm = HuggingFaceEndpoint(
+                repo_id=model_name or "meta-llama/Llama-3.2-3B-Instruct",
+                temperature=0.1,
+                max_new_tokens=512,
+                huggingfacehub_api_token=hf_token,
+                timeout=60  # 60 second timeout to prevent hanging
+            )
+            self.llm = ChatHuggingFace(llm=llm)
+
         self.graph = self._build_graph()
     
     def _build_graph(self) -> StateGraph:
@@ -234,6 +259,95 @@ Example format:
             "next_step": "",
             "final_answer": ""
         }
-        
+
         result = self.graph.invoke(initial_state)
-        return result["final_answer"]
+        return result["final_answer"]
+
+    def stream_query(self, user_query: str):
+        """Process a user query and stream the answer token by token."""
+        # First run analysis and retrieval (non-streaming)
+        initial_state = {
+            "messages": [],
+            "query": user_query,
+            "retrieved_context": [],
+            "action_items": [],
+            "blockers": [],
+            "next_step": "",
+            "final_answer": ""
+        }
+
+        # Run through analysis and retrieval nodes
+        state = self.analyze_query(initial_state)
+        state = self.retrieve_context(state)
+
+        # Determine route and get additional data
+        route = self.route_after_retrieval(state)
+        if route == "action_items":
+            state = self.get_action_items(state)
+        elif route == "blockers":
+            state = self.get_blockers(state)
+
+        # Now stream the final answer generation
+        query = state["query"]
+        context = state.get("retrieved_context", [])
+        action_items = state.get("action_items", [])
+        blockers = state.get("blockers", [])
+
+        # Build context string
+        context_parts = []
+
+        if context:
+            context_parts.append("Relevant meeting context:")
+            for i, result in enumerate(context[:3], 1):
+                context_parts.append(f"\n[Context {i}]")
+                context_parts.append(result['content'])
+                if 'metadata' in result:
+                    meta = result['metadata']
+                    context_parts.append(f"(From: {meta.get('project', 'Unknown')} - {meta.get('title', 'Unknown')})")
+
+        if action_items:
+            context_parts.append("\nOpen Action Items:")
+            for item in action_items:
+                assignee = f" ({item['assignee']})" if item.get('assignee') else ""
+                deadline = f" by {item['deadline']}" if item.get('deadline') else ""
+                context_parts.append(f"- {item['task']}{assignee}{deadline}")
+
+        if blockers:
+            context_parts.append("\nCurrent Blockers:")
+            for blocker in blockers:
+                context_parts.append(f"- {blocker['blocker']}")
+
+        context_str = "\n".join(context_parts)
+
+        # Generate streaming answer
+        system_prompt = """You are a helpful AI assistant that helps users manage their projects.
+Use the provided context to answer the user's question accurately and concisely.
+Format your response using bullet points for clarity.
+For action items, list the task with the assignee in parentheses at the end.
+For blockers and risks, list them directly without project names.
+Keep responses brief and to the point. Avoid lengthy explanations.
+Example format:
+## Next Actions
+- Task description (Assignee) by deadline
+- Another task (Assignee)
+
+## Blockers/Risks
+- Blocker description
+- Another blocker"""
+
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=f"Context:\n{context_str}\n\nQuestion: {query}\n\nAnswer:")
+        ]
+
+        # Stream tokens
+        full_response = ""
+        try:
+            for chunk in self.llm.stream(messages):
+                if hasattr(chunk, 'content') and chunk.content:
+                    full_response += chunk.content
+                    yield full_response
+        except Exception:
+            # Fallback to non-streaming if streaming not supported
+            response = self.llm.invoke(messages)
+            yield response.content

src/rag.py

@@ -197,11 +197,11 @@ class ProjectRAG:
     def get_recent_decisions(self, project: str = None, limit: int = 10) -> List[Dict[str, Any]]:
         """Get recent decisions, optionally filtered by project."""
         decisions = []
-        
+
         for meeting in sorted(self.meetings, key=lambda m: m.date or datetime.min, reverse=True):
             if project and meeting.project_name != project:
                 continue
-            
+
             for decision in meeting.decisions:
                 decisions.append({
                     'project': meeting.project_name,
@@ -209,8 +209,57 @@ class ProjectRAG:
                     'date': meeting.date,
                     'decision': decision
                 })
-                
+
                 if len(decisions) >= limit:
                     return decisions
-        
+
         return decisions
+
+    def get_project_documents(self, project: str) -> List:
+        """Get all meeting documents for a specific project."""
+        from langchain_core.documents import Document
+
+        documents = []
+        for meeting in sorted(self.meetings, key=lambda m: m.date or datetime.min):
+            if meeting.project_name != project:
+                continue
+
+            # Build full meeting content
+            doc_parts = [
+                f"# Meeting: {meeting.title}",
+                f"**Date:** {meeting.date.strftime('%Y-%m-%d') if meeting.date else 'Unknown'}",
+            ]
+
+            if meeting.participants:
+                doc_parts.append(f"**Participants:** {', '.join(meeting.participants)}")
+
+            if meeting.discussion:
+                doc_parts.append(f"\n## Discussion\n{meeting.discussion}")
+
+            if meeting.decisions:
+                doc_parts.append("\n## Decisions")
+                doc_parts.extend([f"- {d}" for d in meeting.decisions])
+
+            if meeting.action_items:
+                doc_parts.append("\n## Action Items")
+                for item in meeting.action_items:
+                    status = "[x]" if item.completed else "[ ]"
+                    assignee = f"{item.assignee}: " if item.assignee else ""
+                    deadline = f" (by {item.deadline})" if item.deadline else ""
+                    doc_parts.append(f"- {status} {assignee}{item.task}{deadline}")
+
+            if meeting.blockers:
+                doc_parts.append("\n## Blockers")
+                doc_parts.extend([f"- {b}" for b in meeting.blockers])
+
+            full_content = "\n".join(doc_parts)
+            documents.append(Document(
+                page_content=full_content,
+                metadata={
+                    "project": meeting.project_name,
+                    "title": meeting.title,
+                    "date": meeting.date.isoformat() if meeting.date else ""
+                }
+            ))
+
+        return documents

tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for Sherlock Project Assistant."""

tests/conftest.py

@@ -0,0 +1,70 @@
+"""Pytest configuration and fixtures."""
+import pytest
+import os
+from pathlib import Path
+import tempfile
+import shutil
+
+
+@pytest.fixture
+def sample_meeting_md():
+    """Sample meeting markdown content."""
+    return """# Meeting: Sprint Planning
+Date: 2025-01-15
+Participants: Alice, Bob, Charlie
+
+## Discussion
+We discussed the new feature requirements and timeline.
+The team agreed on the architecture approach.
+
+## Decisions
+- Use PostgreSQL for the database
+- Deploy on AWS ECS
+
+## Action Items
+- [ ] Alice: Implement login page by 2025-01-20
+- [ ] Bob: Set up CI/CD pipeline by 2025-01-18
+- [x] Charlie: Review requirements (completed)
+
+## Blockers
+- Waiting for API credentials from vendor
+- Need design approval from stakeholders
+"""
+
+
+@pytest.fixture
+def temp_data_dir(sample_meeting_md):
+    """Create a temporary data directory with sample meetings."""
+    temp_dir = tempfile.mkdtemp()
+    data_dir = Path(temp_dir) / "data"
+
+    # Create project structure
+    project_dir = data_dir / "test_project" / "meetings"
+    project_dir.mkdir(parents=True)
+
+    # Write sample meeting
+    meeting_file = project_dir / "2025-01-15-sprint-planning.md"
+    meeting_file.write_text(sample_meeting_md)
+
+    yield data_dir
+
+    # Cleanup
+    shutil.rmtree(temp_dir)
+
+
+@pytest.fixture
+def hf_token():
+    """Get HuggingFace token from environment."""
+    token = os.getenv("HF_TOKEN")
+    if not token:
+        pytest.skip("HF_TOKEN not set - skipping HuggingFace tests")
+    return token
+
+
+@pytest.fixture
+def google_api_key():
+    """Get Google API key from environment."""
+    key = os.getenv("GOOGLE_API_KEY")
+    if not key:
+        pytest.skip("GOOGLE_API_KEY not set - skipping Google API tests")
+    return key

tests/test_app.py

@@ -0,0 +1,408 @@
+"""Tests for app.py functionality - Upload Meeting and Create Project."""
+import pytest
+import os
+from pathlib import Path
+import tempfile
+import shutil
+
+# Import app functions
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.rag import ProjectRAG
+from src.parsers import MeetingParser
+
+
+# Sample raw meeting notes for testing
+SAMPLE_RAW_NOTES_QUANTUM = """
+We had a sync meeting about the quantum error correction project.
+Dr. Chen presented the new surface code implementation results.
+The decoder is showing 15ms latency which is too slow for real-time correction.
+
+Sarah mentioned we got access to IBM's 127-qubit Eagle processor next month.
+Marcus is still blocked on the FPGA development - waiting for the new boards.
+
+We decided to switch from Union-Find to MWPM decoder for better accuracy.
+Also agreed to target 1ms latency for the final system.
+
+Tasks:
+- Dr. Chen will optimize the decoder by end of week
+- Sarah needs to prepare the calibration scripts for IBM hardware
+- Marcus to follow up with vendor about FPGA delivery
+"""
+
+SAMPLE_RAW_NOTES_NEW_PROJECT = """
+Kickoff meeting for the new recommendation engine project.
+Team: Alice, Bob, Carol, David
+
+Discussed architecture options - decided on collaborative filtering approach.
+Bob raised concern about cold start problem for new users.
+
+Alice will research embedding models this week.
+Carol to set up the data pipeline by Friday.
+David blocked on getting production database access.
+
+Next meeting scheduled for Monday.
+"""
+
+
+class TestMeetingParser:
+    """Test meeting parsing functionality."""
+
+    def test_parse_action_items_from_raw_notes(self):
+        """Test that action items can be extracted from structured notes."""
+        # Create a structured meeting file
+        structured_content = """# Meeting: Test Meeting
+Date: 2025-01-30
+Participants: Alice, Bob
+
+## Discussion
+Test discussion.
+
+## Action Items
+- [ ] Alice: Complete task by 2025-02-05
+- [ ] Bob: Review code
+- [x] Carol: Setup done (completed)
+
+## Blockers
+- Waiting for API access
+"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False) as f:
+            f.write(structured_content)
+            temp_path = Path(f.name)
+
+        try:
+            meeting = MeetingParser.parse(temp_path, "test_project")
+            assert meeting is not None
+            assert len(meeting.action_items) == 3
+
+            # Check open items
+            open_items = [a for a in meeting.action_items if not a.completed]
+            assert len(open_items) == 2
+
+            # Check assignees
+            assignees = [a.assignee for a in meeting.action_items if a.assignee]
+            assert "Alice" in assignees
+            assert "Bob" in assignees
+        finally:
+            os.unlink(temp_path)
+
+    def test_parse_blockers(self):
+        """Test blocker extraction."""
+        structured_content = """# Meeting: Blocker Test
+Date: 2025-01-30
+Participants: Team
+
+## Discussion
+Discussed blockers.
+
+## Blockers
+- Waiting for hardware delivery
+- Need security clearance for data access
+- Vendor has not responded to queries
+"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False) as f:
+            f.write(structured_content)
+            temp_path = Path(f.name)
+
+        try:
+            meeting = MeetingParser.parse(temp_path, "test_project")
+            assert meeting is not None
+            assert len(meeting.blockers) == 3
+            # blockers is a List[str], not objects
+            assert any("hardware" in b.lower() for b in meeting.blockers)
+        finally:
+            os.unlink(temp_path)
+
+
+class TestProjectCreation:
+    """Test creating new projects."""
+
+    def test_create_new_project_directory(self):
+        """Test that new project directories are created correctly."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_name = "test_new_project"
+            project_dir = Path(temp_dir) / project_name / "meetings"
+
+            # Simulate what app.py does
+            project_dir.mkdir(parents=True, exist_ok=True)
+
+            assert project_dir.exists()
+            assert project_dir.is_dir()
+            assert (Path(temp_dir) / project_name).exists()
+
+    def test_save_meeting_to_new_project(self):
+        """Test saving a meeting file to a new project."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_name = "recommendation_engine"
+            meeting_date = "2025-01-30"
+            meeting_title = "kickoff"
+
+            project_dir = Path(temp_dir) / project_name / "meetings"
+            project_dir.mkdir(parents=True, exist_ok=True)
+
+            filename = f"{meeting_date}-{meeting_title}.md"
+            file_path = project_dir / filename
+
+            content = """# Meeting: Kickoff
+Date: 2025-01-30
+Participants: Alice, Bob
+
+## Discussion
+Initial project discussion.
+
+## Action Items
+- [ ] Alice: Research models by 2025-02-05
+
+## Blockers
+- Need database access
+"""
+            with open(file_path, 'w') as f:
+                f.write(content)
+
+            assert file_path.exists()
+
+            # Verify RAG can load it
+            rag = ProjectRAG(Path(temp_dir))
+            rag.load_and_index()
+
+            projects = rag.get_all_projects()
+            assert project_name in projects
+
+            # Verify action items are indexed
+            action_items = rag.get_open_action_items(project=project_name)
+            assert len(action_items) >= 1
+
+    def test_create_project_with_special_characters(self):
+        """Test project creation handles names properly."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Test with underscores and numbers
+            project_name = "project_v2_2025"
+            project_dir = Path(temp_dir) / project_name / "meetings"
+            project_dir.mkdir(parents=True, exist_ok=True)
+
+            assert project_dir.exists()
+
+
+class TestUploadMeeting:
+    """Test the upload meeting functionality."""
+
+    def test_meeting_file_naming(self):
+        """Test that meeting files are named correctly."""
+        meeting_date = "2025-01-30"
+        meeting_title = "Sprint Planning"
+
+        # Simulate the naming logic from app.py
+        filename = f"{meeting_date}-{meeting_title.lower().replace(' ', '-')}.md"
+
+        assert filename == "2025-01-30-sprint-planning.md"
+
+    def test_meeting_file_naming_no_title(self):
+        """Test meeting file naming when no title provided."""
+        meeting_date = "2025-01-30"
+        meeting_title = None
+
+        filename = f"{meeting_date}-{meeting_title.lower().replace(' ', '-') if meeting_title else 'meeting'}.md"
+
+        assert filename == "2025-01-30-meeting.md"
+
+    def test_quantum_project_upload(self):
+        """Test uploading a meeting to quantum_computing project."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create existing quantum_computing project
+            quantum_dir = Path(temp_dir) / "quantum_computing" / "meetings"
+            quantum_dir.mkdir(parents=True)
+
+            # Add an existing meeting
+            existing_meeting = """# Meeting: Previous Sync
+Date: 2025-01-25
+Participants: Dr. Chen, Sarah
+
+## Discussion
+Previous work discussion.
+"""
+            (quantum_dir / "2025-01-25-previous-sync.md").write_text(existing_meeting)
+
+            # Now simulate uploading a new meeting
+            new_meeting_content = """# Meeting: Decoder Optimization Review
+Date: 2025-01-30
+Participants: Dr. Chen, Sarah, Marcus
+
+## Discussion
+Reviewed decoder performance. Current latency is 15ms, target is 1ms.
+Discussed MWPM vs Union-Find approaches.
+
+## Decisions
+- Switch to MWPM decoder for better accuracy
+- Target 1ms latency for production
+
+## Action Items
+- [ ] Dr. Chen: Implement MWPM decoder by 2025-02-07
+- [ ] Sarah: Benchmark on IBM simulator by 2025-02-10
+- [ ] Marcus: Order additional FPGA boards
+
+## Blockers
+- FPGA delivery delayed by 2 weeks
+- Need IBM quantum credits approval
+"""
+            new_file = quantum_dir / "2025-01-30-decoder-optimization-review.md"
+            new_file.write_text(new_meeting_content)
+
+            # Verify both meetings exist
+            meetings = list(quantum_dir.glob("*.md"))
+            assert len(meetings) == 2
+
+            # Verify RAG indexes both
+            rag = ProjectRAG(Path(temp_dir))
+            rag.load_and_index()
+
+            assert "quantum_computing" in rag.get_all_projects()
+            assert len(rag.meetings) == 2
+
+            # Verify action items
+            action_items = rag.get_open_action_items(project="quantum_computing")
+            assert len(action_items) >= 3
+
+            # Verify blockers
+            blockers = rag.get_blockers(project="quantum_computing")
+            assert len(blockers) >= 2
+
+
+class TestRAGWithMultipleProjects:
+    """Test RAG functionality with multiple projects."""
+
+    def test_multiple_projects_isolation(self):
+        """Test that queries can be isolated to specific projects."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create two projects
+            project1_dir = Path(temp_dir) / "quantum_computing" / "meetings"
+            project2_dir = Path(temp_dir) / "covid_prediction" / "meetings"
+            project1_dir.mkdir(parents=True)
+            project2_dir.mkdir(parents=True)
+
+            # Add meeting to project 1
+            (project1_dir / "2025-01-30-quantum.md").write_text("""# Meeting: Quantum Sync
+Date: 2025-01-30
+Participants: Dr. Chen
+
+## Action Items
+- [ ] Dr. Chen: Optimize decoder
+
+## Blockers
+- FPGA delivery delayed
+""")
+
+            # Add meeting to project 2
+            (project2_dir / "2025-01-30-covid.md").write_text("""# Meeting: COVID Analysis
+Date: 2025-01-30
+Participants: Dr. Foster
+
+## Action Items
+- [ ] Dr. Foster: Review model accuracy
+
+## Blockers
+- Data quality issues with GISAID
+""")
+
+            rag = ProjectRAG(Path(temp_dir))
+            rag.load_and_index()
+
+            # Test project filtering
+            quantum_items = rag.get_open_action_items(project="quantum_computing")
+            covid_items = rag.get_open_action_items(project="covid_prediction")
+
+            assert any("decoder" in item['task'].lower() for item in quantum_items)
+            assert any("model" in item['task'].lower() for item in covid_items)
+
+            # Test blocker filtering
+            quantum_blockers = rag.get_blockers(project="quantum_computing")
+            covid_blockers = rag.get_blockers(project="covid_prediction")
+
+            assert any("fpga" in b['blocker'].lower() for b in quantum_blockers)
+            assert any("gisaid" in b['blocker'].lower() for b in covid_blockers)
+
+    def test_all_projects_query(self):
+        """Test querying across all projects."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create two projects with meetings
+            for project in ["project_a", "project_b"]:
+                project_dir = Path(temp_dir) / project / "meetings"
+                project_dir.mkdir(parents=True)
+                (project_dir / "2025-01-30-meeting.md").write_text(f"""# Meeting: {project} Sync
+Date: 2025-01-30
+Participants: Team
+
+## Action Items
+- [ ] Someone: Task for {project}
+""")
+
+            rag = ProjectRAG(Path(temp_dir))
+            rag.load_and_index()
+
+            # Get all action items without filter
+            all_items = rag.get_open_action_items()
+            assert len(all_items) >= 2
+
+
+class TestIntegrationUploadMeeting:
+    """Integration tests for upload meeting with LLM (requires tokens)."""
+
+    def test_structure_meeting_hf(self):
+        """Test meeting structuring with HuggingFace."""
+        hf_token = os.getenv("HF_TOKEN")
+        if not hf_token:
+            pytest.skip("HF_TOKEN not set")
+
+        from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+        from langchain_core.messages import SystemMessage, HumanMessage
+
+        endpoint = HuggingFaceEndpoint(
+            repo_id="meta-llama/Llama-3.2-3B-Instruct",
+            temperature=0.3,
+            max_new_tokens=1024,
+            huggingfacehub_api_token=hf_token,
+            timeout=60
+        )
+        llm = ChatHuggingFace(llm=endpoint)
+
+        system_prompt = """Structure these meeting notes into markdown with sections:
+# Meeting: [title], Date:, Participants:, ## Discussion, ## Action Items, ## Blockers"""
+
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=f"Raw notes: {SAMPLE_RAW_NOTES_QUANTUM}")
+        ]
+
+        response = llm.invoke(messages)
+        assert response.content is not None
+        assert len(response.content) > 100
+        # Should have some structure
+        assert "action" in response.content.lower() or "task" in response.content.lower()
+
+    def test_structure_meeting_google(self):
+        """Test meeting structuring with Google."""
+        api_key = os.getenv("GOOGLE_API_KEY")
+        if not api_key:
+            pytest.skip("GOOGLE_API_KEY not set")
+
+        from langchain_google_genai import ChatGoogleGenerativeAI
+        from langchain_core.messages import SystemMessage, HumanMessage
+
+        llm = ChatGoogleGenerativeAI(
+            model="gemini-2.0-flash",
+            temperature=0.3,
+            google_api_key=api_key,
+            timeout=60
+        )
+
+        system_prompt = """Structure these meeting notes into markdown with sections:
+# Meeting: [title], Date:, Participants:, ## Discussion, ## Action Items, ## Blockers"""
+
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=f"Raw notes: {SAMPLE_RAW_NOTES_NEW_PROJECT}")
+        ]
+
+        response = llm.invoke(messages)
+        assert response.content is not None
+        assert len(response.content) > 100

tests/test_evaluation.py

@@ -0,0 +1,197 @@
+"""
+Agent Evaluation Tests - Measures agent quality and performance.
+
+Run with: pytest tests/test_evaluation.py -v -s
+"""
+import pytest
+import time
+import os
+from pathlib import Path
+from dataclasses import dataclass
+from typing import List
+
+# Skip if no API tokens available
+pytestmark = pytest.mark.skipif(
+    not (os.getenv("HF_TOKEN") or os.getenv("GOOGLE_API_KEY")),
+    reason="Requires HF_TOKEN or GOOGLE_API_KEY"
+)
+
+
+@dataclass
+class EvalCase:
+    """Test case for evaluation."""
+    name: str
+    query: str
+    expected_keywords: List[str]
+    category: str
+
+
+# Evaluation test cases - keywords aligned with actual agent responses
+EVAL_CASES = [
+    EvalCase(
+        name="action_items_query",
+        query="What are the open action items?",
+        expected_keywords=["action", "item", "implement", "complete", "next"],
+        category="action_items"
+    ),
+    EvalCase(
+        name="blockers_query",
+        query="What blockers do we have?",
+        expected_keywords=["blocker", "block", "risk", "waiting", "issue"],
+        category="blockers"
+    ),
+    EvalCase(
+        name="project_summary",
+        query="Give me a summary of the project",
+        expected_keywords=["project", "meeting", "discuss", "team", "work"],
+        category="general"
+    ),
+    EvalCase(
+        name="next_steps_query",
+        query="What should we do next?",
+        expected_keywords=["next", "action", "should", "need", "implement"],
+        category="action_items"
+    ),
+    EvalCase(
+        name="issues_query",
+        query="What issues or problems were discussed?",
+        expected_keywords=["issue", "problem", "blocker", "challenge", "risk"],
+        category="blockers"
+    ),
+]
+
+
+class EvaluationMetrics:
+    """Collect and compute evaluation metrics."""
+
+    def __init__(self):
+        self.results = []
+
+    def add_result(self, case: EvalCase, response: str, latency: float):
+        """Add a single evaluation result."""
+        # Keyword match score
+        keywords_found = sum(
+            1 for kw in case.expected_keywords
+            if kw.lower() in response.lower()
+        )
+        keyword_score = keywords_found / len(case.expected_keywords) if case.expected_keywords else 1.0
+
+        # Response validity
+        is_valid = (
+            len(response) > 50 and
+            not response.startswith("❌") and
+            not response.startswith("⚠️")
+        )
+
+        # Response length (penalize too short or too long)
+        length_score = 1.0
+        if len(response) < 100:
+            length_score = 0.5
+        elif len(response) > 2000:
+            length_score = 0.8
+
+        self.results.append({
+            "name": case.name,
+            "category": case.category,
+            "keyword_score": keyword_score,
+            "is_valid": is_valid,
+            "length_score": length_score,
+            "latency_ms": latency,
+            "response_length": len(response)
+        })
+
+    def compute_summary(self) -> dict:
+        """Compute summary metrics."""
+        if not self.results:
+            return {}
+
+        total = len(self.results)
+        passed = sum(1 for r in self.results if r["keyword_score"] >= 0.4 and r["is_valid"]  and r["response_length"] >= 100)
+
+        avg_keyword_score = sum(r["keyword_score"] for r in self.results) / total
+        avg_latency = sum(r["latency_ms"] for r in self.results) / total
+        avg_length = sum(r["response_length"] for r in self.results) / total
+
+        return {
+            "total_cases": total,
+            "passed": passed,
+            "failed": total - passed,
+            "pass_rate": round(passed / total * 100, 1),
+            "avg_keyword_score": round(avg_keyword_score * 100, 1),
+            "avg_latency_ms": round(avg_latency, 0),
+            "avg_response_length": round(avg_length, 0)
+        }
+
+
+@pytest.fixture(scope="module")
+def agent():
+    """Initialize agent for evaluation."""
+    from src.rag import ProjectRAG
+    from src.agent import ProjectAgent
+
+    data_dir = Path("./data")
+    rag = ProjectRAG(data_dir)
+    rag.load_and_index()
+
+    # Use Google if available (faster), otherwise HuggingFace
+    if os.getenv("GOOGLE_API_KEY"):
+        agent = ProjectAgent(rag, provider="google")
+    else:
+        agent = ProjectAgent(rag, provider="huggingface")
+
+    return agent
+
+
+@pytest.fixture(scope="module")
+def metrics():
+    """Shared metrics collector."""
+    return EvaluationMetrics()
+
+
+class TestAgentEvaluation:
+    """Evaluation test suite."""
+
+    @pytest.mark.parametrize("case", EVAL_CASES, ids=lambda c: c.name)
+    def test_query(self, agent, metrics, case):
+        """Test individual query case."""
+        start = time.time()
+        response = agent.query(case.query)
+        latency = (time.time() - start) * 1000
+
+        metrics.add_result(case, response, latency)
+
+        # Basic assertions
+        assert response is not None
+        assert len(response) > 0
+
+        # Check at least one keyword found
+        keywords_found = sum(
+            1 for kw in case.expected_keywords
+            if kw.lower() in response.lower()
+        )
+
+        print(f"\n  Query: {case.query}")
+        print(f"  Keywords found: {keywords_found}/{len(case.expected_keywords)}")
+        print(f"  Latency: {latency:.0f}ms")
+        print(f"  Response length: {len(response)} chars")
+
+
+def test_evaluation_summary(metrics):
+    """Print evaluation summary after all tests."""
+    summary = metrics.compute_summary()
+
+    if summary:
+        print("\n" + "="*60)
+        print("EVALUATION SUMMARY")
+        print("="*60)
+        print(f"Total Cases:        {summary['total_cases']}")
+        print(f"Passed:             {summary['passed']}")
+        print(f"Failed:             {summary['failed']}")
+        print(f"Pass Rate:          {summary['pass_rate']}%")
+        print(f"Avg Keyword Score:  {summary['avg_keyword_score']}%")
+        print(f"Avg Latency:        {summary['avg_latency_ms']}ms")
+        print(f"Avg Response Len:   {summary['avg_response_length']} chars")
+        print("="*60)
+
+        # Assert minimum quality (80% pass rate required)
+        assert summary["pass_rate"] >= 80, f"Pass rate too low: {summary['pass_rate']}%"

tests/test_integration.py

@@ -0,0 +1,151 @@
+"""Integration tests for LLM providers."""
+import pytest
+import os
+from pathlib import Path
+import tempfile
+from src.rag import ProjectRAG
+from src.agent import ProjectAgent
+
+
+# Sample meeting for testing
+SAMPLE_MEETING = """# Meeting: Test Sprint Planning
+Date: 2025-01-15
+Participants: Alice, Bob
+
+## Discussion
+Discussed the test implementation.
+
+## Decisions
+- Use pytest for testing
+
+## Action Items
+- [ ] Alice: Write unit tests by 2025-01-20
+- [ ] Bob: Review code by 2025-01-18
+
+## Blockers
+- Waiting for API access
+"""
+
+
+@pytest.fixture
+def test_rag():
+    """Create a RAG system with test data."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Create data structure
+        data_dir = Path(temp_dir) / "data"
+        project_dir = data_dir / "test_project" / "meetings"
+        project_dir.mkdir(parents=True)
+
+        # Write sample meeting
+        (project_dir / "2025-01-15-sprint.md").write_text(SAMPLE_MEETING)
+
+        # Create persistent dir for ChromaDB
+        persist_dir = Path(temp_dir) / "chroma"
+
+        # Initialize RAG
+        rag = ProjectRAG(data_dir, persist_dir=persist_dir)
+        rag.load_and_index()
+
+        yield rag
+
+
+class TestHuggingFaceProvider:
+    """Integration tests for HuggingFace provider."""
+
+    def test_hf_agent_creation(self, test_rag):
+        """Test that HuggingFace agent can be created with valid token."""
+        hf_token = os.getenv("HF_TOKEN")
+        if not hf_token:
+            pytest.skip("HF_TOKEN not set")
+
+        agent = ProjectAgent(test_rag, provider="huggingface")
+        assert agent is not None
+        assert agent.provider == "huggingface"
+        assert agent.llm is not None
+
+    def test_hf_simple_query(self, test_rag):
+        """Test a simple query with HuggingFace."""
+        hf_token = os.getenv("HF_TOKEN")
+        if not hf_token:
+            pytest.skip("HF_TOKEN not set")
+
+        agent = ProjectAgent(test_rag, provider="huggingface")
+        response = agent.query("What are the action items?")
+
+        assert response is not None
+        assert len(response) > 0
+        # Should mention Alice or Bob from the test data
+        assert "alice" in response.lower() or "bob" in response.lower() or "test" in response.lower()
+
+    def test_hf_blockers_query(self, test_rag):
+        """Test blockers query with HuggingFace."""
+        hf_token = os.getenv("HF_TOKEN")
+        if not hf_token:
+            pytest.skip("HF_TOKEN not set")
+
+        agent = ProjectAgent(test_rag, provider="huggingface")
+        response = agent.query("What blockers do we have?")
+
+        assert response is not None
+        assert len(response) > 0
+
+    def test_hf_invalid_token(self, test_rag):
+        """Test that invalid token raises appropriate error."""
+        os.environ["HF_TOKEN"] = "invalid_token_12345"
+
+        agent = ProjectAgent(test_rag, provider="huggingface")
+
+        with pytest.raises(Exception) as exc_info:
+            agent.query("What are the action items?")
+
+        # Should get an authentication error
+        error_msg = str(exc_info.value).lower()
+        assert "401" in error_msg or "unauthorized" in error_msg or "invalid" in error_msg or "error" in error_msg
+
+
+class TestGoogleProvider:
+    """Integration tests for Google provider."""
+
+    def test_google_agent_creation(self, test_rag):
+        """Test that Google agent can be created with valid key."""
+        api_key = os.getenv("GOOGLE_API_KEY")
+        if not api_key:
+            pytest.skip("GOOGLE_API_KEY not set")
+
+        agent = ProjectAgent(test_rag, provider="google")
+        assert agent is not None
+        assert agent.provider == "google"
+        assert agent.llm is not None
+
+    def test_google_simple_query(self, test_rag):
+        """Test a simple query with Google."""
+        api_key = os.getenv("GOOGLE_API_KEY")
+        if not api_key:
+            pytest.skip("GOOGLE_API_KEY not set")
+
+        agent = ProjectAgent(test_rag, provider="google")
+        response = agent.query("What are the action items?")
+
+        assert response is not None
+        assert len(response) > 0
+
+    def test_google_blockers_query(self, test_rag):
+        """Test blockers query with Google."""
+        api_key = os.getenv("GOOGLE_API_KEY")
+        if not api_key:
+            pytest.skip("GOOGLE_API_KEY not set")
+
+        agent = ProjectAgent(test_rag, provider="google")
+        response = agent.query("What blockers do we have?")
+
+        assert response is not None
+        assert len(response) > 0
+
+    def test_google_invalid_key(self, test_rag):
+        """Test that invalid key raises appropriate error."""
+        os.environ["GOOGLE_API_KEY"] = "invalid_key_12345"
+
+        agent = ProjectAgent(test_rag, provider="google")
+
+        with pytest.raises(Exception):
+            agent.query("What are the action items?")

tests/test_parsers.py

@@ -0,0 +1,97 @@
+"""Tests for meeting parsers."""
+import pytest
+from datetime import datetime
+from pathlib import Path
+from src.parsers import MeetingParser, ActionItem, MeetingNote, load_meetings_from_directory
+
+
+class TestMeetingParser:
+    """Tests for MeetingParser class."""
+
+    def test_parse_date_iso_format(self):
+        """Test parsing ISO format date."""
+        result = MeetingParser.parse_date("2025-01-15")
+        assert result == datetime(2025, 1, 15)
+
+    def test_parse_date_us_format(self):
+        """Test parsing US format date."""
+        result = MeetingParser.parse_date("01/15/2025")
+        assert result == datetime(2025, 1, 15)
+
+    def test_parse_date_verbose_format(self):
+        """Test parsing verbose format date."""
+        result = MeetingParser.parse_date("January 15, 2025")
+        assert result == datetime(2025, 1, 15)
+
+    def test_parse_date_invalid(self):
+        """Test parsing invalid date returns None."""
+        result = MeetingParser.parse_date("not a date")
+        assert result is None
+
+    def test_parse_action_item_simple(self):
+        """Test parsing simple action item."""
+        result = MeetingParser.parse_action_item("- [ ] Complete the report")
+        assert result is not None
+        assert result.task == "Complete the report"
+        assert result.completed is False
+        assert result.assignee is None
+
+    def test_parse_action_item_completed(self):
+        """Test parsing completed action item."""
+        result = MeetingParser.parse_action_item("- [x] Review PR")
+        assert result is not None
+        assert result.completed is True
+
+    def test_parse_action_item_with_assignee(self):
+        """Test parsing action item with assignee."""
+        result = MeetingParser.parse_action_item("- [ ] Alice: Implement feature")
+        assert result is not None
+        assert result.assignee == "Alice"
+        assert result.task == "Implement feature"
+
+    def test_parse_action_item_with_deadline(self):
+        """Test parsing action item with deadline."""
+        result = MeetingParser.parse_action_item("- [ ] Bob: Fix bug by 2025-01-20")
+        assert result is not None
+        assert result.assignee == "Bob"
+        assert result.deadline == "2025-01-20"
+
+    def test_parse_meeting_file(self, temp_data_dir):
+        """Test parsing a complete meeting file."""
+        meeting_file = temp_data_dir / "test_project" / "meetings" / "2025-01-15-sprint-planning.md"
+        result = MeetingParser.parse(meeting_file, "test_project")
+
+        assert result is not None
+        assert result.project_name == "test_project"
+        assert result.title == "Sprint Planning"
+        assert result.date == datetime(2025, 1, 15)
+        assert "Alice" in result.participants
+        assert "Bob" in result.participants
+        assert len(result.decisions) == 2
+        assert len(result.action_items) == 3
+        assert len(result.blockers) == 2
+
+    def test_parse_nonexistent_file(self):
+        """Test parsing nonexistent file returns None."""
+        result = MeetingParser.parse(Path("/nonexistent/file.md"), "test")
+        assert result is None
+
+
+class TestLoadMeetings:
+    """Tests for load_meetings_from_directory function."""
+
+    def test_load_meetings_from_directory(self, temp_data_dir):
+        """Test loading meetings from directory."""
+        meetings = load_meetings_from_directory(temp_data_dir)
+        assert len(meetings) == 1
+        assert meetings[0].project_name == "test_project"
+
+    def test_load_meetings_empty_directory(self, tmp_path):
+        """Test loading from empty directory."""
+        meetings = load_meetings_from_directory(tmp_path)
+        assert len(meetings) == 0
+
+    def test_load_meetings_nonexistent_directory(self):
+        """Test loading from nonexistent directory."""
+        meetings = load_meetings_from_directory(Path("/nonexistent"))
+        assert len(meetings) == 0

tests/test_rag.py

@@ -0,0 +1,96 @@
+"""Tests for RAG system."""
+import pytest
+from pathlib import Path
+import tempfile
+import shutil
+from src.rag import ProjectRAG
+
+
+class TestProjectRAG:
+    """Tests for ProjectRAG class."""
+
+    def test_rag_initialization(self, temp_data_dir):
+        """Test RAG system initializes correctly."""
+        with tempfile.TemporaryDirectory() as persist_dir:
+            rag = ProjectRAG(temp_data_dir, persist_dir=Path(persist_dir))
+            assert rag is not None
+            assert rag.data_dir == temp_data_dir
+
+    def test_load_and_index(self, temp_data_dir):
+        """Test loading and indexing meetings."""
+        with tempfile.TemporaryDirectory() as persist_dir:
+            rag = ProjectRAG(temp_data_dir, persist_dir=Path(persist_dir))
+            rag.load_and_index()
+
+            assert len(rag.meetings) == 1
+            assert rag.meetings[0].project_name == "test_project"
+
+    def test_get_all_projects(self, temp_data_dir):
+        """Test getting all project names."""
+        with tempfile.TemporaryDirectory() as persist_dir:
+            rag = ProjectRAG(temp_data_dir, persist_dir=Path(persist_dir))
+            rag.load_and_index()
+
+            projects = rag.get_all_projects()
+            assert "test_project" in projects
+
+    def test_get_open_action_items(self, temp_data_dir):
+        """Test getting open action items."""
+        with tempfile.TemporaryDirectory() as persist_dir:
+            rag = ProjectRAG(temp_data_dir, persist_dir=Path(persist_dir))
+            rag.load_and_index()
+
+            items = rag.get_open_action_items()
+            # Should have 2 open items (Alice and Bob's tasks)
+            assert len(items) == 2
+
+    def test_get_open_action_items_filtered(self, temp_data_dir):
+        """Test getting open action items filtered by project."""
+        with tempfile.TemporaryDirectory() as persist_dir:
+            rag = ProjectRAG(temp_data_dir, persist_dir=Path(persist_dir))
+            rag.load_and_index()
+
+            items = rag.get_open_action_items(project="test_project")
+            assert len(items) == 2
+
+            items = rag.get_open_action_items(project="nonexistent")
+            assert len(items) == 0
+
+    def test_get_blockers(self, temp_data_dir):
+        """Test getting blockers."""
+        with tempfile.TemporaryDirectory() as persist_dir:
+            rag = ProjectRAG(temp_data_dir, persist_dir=Path(persist_dir))
+            rag.load_and_index()
+
+            blockers = rag.get_blockers()
+            assert len(blockers) == 2
+
+    def test_search(self, temp_data_dir):
+        """Test semantic search."""
+        with tempfile.TemporaryDirectory() as persist_dir:
+            rag = ProjectRAG(temp_data_dir, persist_dir=Path(persist_dir))
+            rag.load_and_index()
+
+            results = rag.search("login page implementation")
+            assert len(results) > 0
+
+    def test_search_with_project_filter(self, temp_data_dir):
+        """Test semantic search with project filter."""
+        with tempfile.TemporaryDirectory() as persist_dir:
+            rag = ProjectRAG(temp_data_dir, persist_dir=Path(persist_dir))
+            rag.load_and_index()
+
+            results = rag.search("login", project_filter="test_project")
+            assert len(results) > 0
+
+            results = rag.search("login", project_filter="nonexistent")
+            assert len(results) == 0
+
+    def test_get_recent_decisions(self, temp_data_dir):
+        """Test getting recent decisions."""
+        with tempfile.TemporaryDirectory() as persist_dir:
+            rag = ProjectRAG(temp_data_dir, persist_dir=Path(persist_dir))
+            rag.load_and_index()
+
+            decisions = rag.get_recent_decisions()
+            assert len(decisions) == 2