Deploy Sherlock

.gitignore

@@ -0,0 +1,9 @@
+.env
+__pycache__/
+*.pyc
+.venv/
+chroma_db/
+*.db
+.DS_Store
+*.log
+.pytest_cache/

.python-version

@@ -0,0 +1 @@
+3.10

app.py

@@ -0,0 +1,333 @@
+"""
+Gradio app for AI Project Assistant.
+"""
+import gradio as gr
+from pathlib import Path
+import os
+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_core.messages import SystemMessage, HumanMessage
+
+# Load environment variables
+load_dotenv()
+
+# Global state - Initialize on startup
+rag = None
+agent = None
+initialized = False
+
+def initialize_on_startup():
+    """Initialize system automatically on startup."""
+    global rag, agent, initialized
+
+    data_dir = Path("./data")
+
+    if not data_dir.exists():
+        return
+
+    try:
+        rag = ProjectRAG(data_dir)
+        rag.load_and_index()
+
+        if rag.meetings:
+            agent = ProjectAgent(rag)
+            initialized = True
+    except Exception as e:
+        print(f"Initialization error: {e}")
+
+# Initialize on module load
+initialize_on_startup()
+
+def chat(message, history, project_filter):
+    """Process chat message."""
+    if not initialized or not agent:
+        yield "⚠️ System initializing... Please wait and try again."
+        return
+
+    try:
+        # Add project context if specified
+        if project_filter and project_filter != "All Projects":
+            enhanced_prompt = f"[Project: {project_filter}] {message}"
+        else:
+            enhanced_prompt = message
+
+        response = agent.query(enhanced_prompt)
+        yield response
+    except Exception as e:
+        yield f"❌ Error: {str(e)}"
+
+def get_projects():
+    """Get list of projects."""
+    if not initialized or not rag:
+        return ["All Projects"]
+
+    projects = rag.get_all_projects()
+    return ["All Projects"] + projects
+
+def structure_meeting(project_name, meeting_title, meeting_date, participants, meeting_text):
+    """Structure meeting notes using AI."""
+    if not project_name or not meeting_text:
+        return "❌ Please provide both project name and meeting notes"
+
+    try:
+        # Use HF Inference API
+        endpoint = HuggingFaceEndpoint(
+            repo_id="meta-llama/Llama-3.2-3B-Instruct",
+            temperature=0.3,
+            max_new_tokens=1024,
+            huggingfacehub_api_token=os.getenv("HF_TOKEN")
+        )
+        llm = ChatHuggingFace(llm=endpoint)
+
+        system_prompt = """You are a meeting notes structuring assistant.
+Convert unstructured meeting notes into a well-formatted markdown document with these sections:
+1. # Meeting: [title]
+2. Date: [date]
+3. Participants: [list]
+4. ## Discussion (key points discussed)
+5. ## Decisions (decisions made)
+6. ## Action Items (as checkboxes with assignee and deadline if mentioned)
+7. ## Blockers (any blockers or issues raised)
+
+Format action items as:
+- [ ] Person: Task description by deadline
+or
+- [ ] Task description (if no person/deadline mentioned)
+
+Extract all relevant information from the raw notes."""
+
+        user_prompt = f"""Structure these meeting notes:
+
+Raw Notes:
+{meeting_text}
+
+Meeting Details:
+- Title: {meeting_title or 'Meeting'}
+- Date: {meeting_date}
+- Participants: {participants or 'Not specified'}
+"""
+
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=user_prompt)
+        ]
+
+        response = llm.invoke(messages)
+        structured_md = response.content
+
+        # Save to file
+        project_dir = Path("data") / project_name / "meetings"
+        project_dir.mkdir(parents=True, exist_ok=True)
+
+        filename = f"{meeting_date}-{meeting_title.lower().replace(' ', '-') if meeting_title else 'meeting'}.md"
+        file_path = project_dir / filename
+
+        with open(file_path, 'w') as f:
+            f.write(structured_md)
+
+        return f"✅ Meeting structured and saved to `{file_path}`\n\n---\n\n{structured_md}"
+
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+# Create Gradio interface with custom CSS
+custom_css = """
+.chatbot-container {
+    background-color: #f7f7f8;
+    border-radius: 8px;
+    padding: 10px;
+}
+.example-panel {
+    background-color: #f0f2f6;
+    border-radius: 8px;
+    padding: 15px;
+    height: 100%;
+}
+/* Mobile responsiveness */
+@media (max-width: 768px) {
+    .row {
+        flex-direction: column !important;
+    }
+    .chatbot-container {
+        margin-top: 10px;
+    }
+}
+"""
+
+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.
+    """)
+
+    # Main tabs
+    with gr.Tabs():
+        # Chat tab
+        with gr.Tab("💬 Chat"):
+            gr.Markdown("### Ask questions about your projects")
+
+            # Project selection dropdown
+            project_dropdown = gr.Dropdown(
+                label="Select Project",
+                choices=get_projects(),
+                value="All Projects",
+                interactive=True
+            )
+
+            # Chat interface with example queries on the side
+            with gr.Row(elem_classes="row"):
+                # Left panel - Example queries (same width as right panel chat box)
+                with gr.Column(scale=1, elem_classes="example-panel"):
+                    gr.Markdown("""
+                    ### 📖 How to Use
+                    1. Select the project you want to query from the dropdown above
+                    2. Type your question in the chat box or use one of the examples below
+                    3. Press Enter or click Send
+
+                    ### 💡 Example Queries
+                    - What are the open action items?
+                    - What blockers do we have?
+                    - What decisions were made?
+                    - What should I focus on next?
+                    - Summarize the project status
+                    """)
+
+                # Right panel - Chat (same width as left panel)
+                with gr.Column(scale=1, elem_classes="chatbot-container"):
+                    chatbot = gr.Chatbot(
+                        label="Chat",
+                        height=350,
+                        type="messages",
+                        show_label=False
+                    )
+
+                    msg = gr.Textbox(
+                        label="Your Message",
+                        placeholder="What are the open action items?",
+                        lines=2,
+                        show_label=False
+                    )
+
+                    with gr.Row():
+                        submit_btn = gr.Button("Send", variant="primary", scale=1)
+                        clear_btn = gr.Button("Clear", scale=1)
+
+            def respond(message, chat_history, project):
+                if not message:
+                    return chat_history, ""
+
+                # Add user message to history
+                chat_history.append({"role": "user", "content": message})
+
+                # Get bot response
+                bot_message = ""
+                for response_chunk in chat(message, chat_history, project):
+                    bot_message = response_chunk
+
+                # Add bot message to history
+                chat_history.append({"role": "assistant", "content": bot_message})
+
+                return chat_history, ""
+
+            submit_btn.click(
+                fn=respond,
+                inputs=[msg, chatbot, project_dropdown],
+                outputs=[chatbot, msg]
+            )
+
+            msg.submit(
+                fn=respond,
+                inputs=[msg, chatbot, project_dropdown],
+                outputs=[chatbot, msg]
+            )
+
+            clear_btn.click(fn=lambda: [], outputs=chatbot)
+
+        # Upload Meeting tab
+        with gr.Tab("📤 Upload Meeting"):
+            gr.Markdown("### Upload plain text meeting notes and let AI structure them")
+
+            # Project selection with toggle
+            with gr.Row():
+                with gr.Column():
+                    project_mode = gr.Radio(
+                        choices=["Use Existing Project", "Create New Project"],
+                        value="Use Existing Project",
+                        label="Project Selection"
+                    )
+
+                    # Existing project dropdown (shown when "Use Existing" is selected)
+                    existing_project = gr.Dropdown(
+                        label="Select Existing Project",
+                        choices=get_projects()[1:],  # Exclude "All Projects"
+                        visible=True
+                    )
+                    # New project textbox (shown when "Create New" is selected)
+                    new_project = gr.Textbox(
+                        label="New Project Name",
+                        placeholder="e.g., mobile_app_redesign",
+                        visible=False
+                    )
+                    upload_title = gr.Textbox(
+                        label="Meeting Title",
+                        placeholder="e.g., Sprint Planning"
+                    )
+                with gr.Column():
+                    upload_date = gr.Textbox(
+                        label="Meeting Date (YYYY-MM-DD)",
+                        value=datetime.now().strftime("%Y-%m-%d"),
+                        placeholder="2025-01-15",
+                        type="text"
+                    )
+                    upload_participants = gr.Textbox(
+                        label="Participants (comma-separated)",
+                        placeholder="e.g., Alice, Bob, Charlie"
+                    )
+
+            # Toggle visibility based on project mode
+            def toggle_project_input(mode):
+                if mode == "Use Existing Project":
+                    return gr.update(visible=True), gr.update(visible=False)
+                else:
+                    return gr.update(visible=False), gr.update(visible=True)
+
+            project_mode.change(
+                fn=toggle_project_input,
+                inputs=[project_mode],
+                outputs=[existing_project, new_project]
+            )
+
+            upload_text = gr.Textbox(
+                label="Meeting Notes (plain text)",
+                placeholder="""Example:
+We discussed the new feature requirements.
+Alice will implement the login page by next Friday.
+Bob raised a concern about the database migration.
+We decided to use PostgreSQL instead of MySQL.
+Charlie is blocked waiting for API credentials.""",
+                lines=10
+            )
+
+            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):
+                """Wrapper to handle both project modes."""
+                # 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)
+
+            structure_btn.click(
+                fn=structure_meeting_wrapper,
+                inputs=[project_mode, existing_project, new_project, upload_title, upload_date, upload_participants, upload_text],
+                outputs=structure_output
+            )
+
+
+# Launch
+if __name__ == "__main__":
+    demo.launch()

app_streamlit.py

@@ -0,0 +1,388 @@
+"""
+Streamlit app for AI Project Assistant.
+"""
+import streamlit as st
+from pathlib import Path
+import os
+from datetime import datetime
+from dotenv import load_dotenv
+from src.rag import ProjectRAG
+from src.agent import ProjectAgent
+from src.parsers import load_meetings_from_directory
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+from langchain_core.messages import SystemMessage, HumanMessage
+
+# Load environment variables
+load_dotenv()
+
+# Page config
+st.set_page_config(
+    page_title="AI Project Assistant",
+    page_icon="🤖",
+    layout="wide"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: bold;
+        margin-bottom: 1rem;
+    }
+    .project-card {
+        padding: 1rem;
+        border-radius: 0.5rem;
+        background-color: #f0f2f6;
+        margin: 0.5rem 0;
+    }
+    .action-item {
+        padding: 0.5rem;
+        margin: 0.25rem 0;
+        border-left: 3px solid #1f77b4;
+        background-color: #e8f4f8;
+    }
+    .blocker {
+        padding: 0.5rem;
+        margin: 0.25rem 0;
+        border-left: 3px solid #d62728;
+        background-color: #ffe8e8;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'rag' not in st.session_state:
+    st.session_state.rag = None
+if 'agent' not in st.session_state:
+    st.session_state.agent = None
+if 'messages' not in st.session_state:
+    st.session_state.messages = []
+if 'initialized' not in st.session_state:
+    st.session_state.initialized = False
+
+
+def initialize_system():
+    """Initialize RAG and Agent systems."""
+    data_dir = Path("./data")
+    
+    if not data_dir.exists():
+        data_dir.mkdir(parents=True)
+        st.warning("Created data directory. Please add your meeting notes to 'data/project_name/meetings/'")
+        return False
+    
+    with st.spinner("Loading and indexing meetings..."):
+        st.session_state.rag = ProjectRAG(data_dir)
+        st.session_state.rag.load_and_index()
+        
+        if not st.session_state.rag.meetings:
+            return False
+        
+        st.session_state.agent = ProjectAgent(st.session_state.rag)
+        st.session_state.initialized = True
+    
+    return True
+
+
+def main():
+    """Main app function."""
+    
+    # Header
+    st.markdown('<div class="main-header">🤖 AI Project Assistant</div>', unsafe_allow_html=True)
+    st.markdown("Your intelligent assistant for managing multiple projects through meeting summaries")
+    
+    # Sidebar
+    with st.sidebar:
+        st.header("⚙️ Settings")
+
+        # Project filter
+        if st.session_state.rag and st.session_state.initialized:
+            projects = st.session_state.rag.get_all_projects()
+            selected_project = st.selectbox(
+                "Select Project",
+                options=["All Projects"] + projects,
+                key="selected_project"
+            )
+            st.session_state.project_filter = None if selected_project == "All Projects" else selected_project
+
+        if st.button("🔄 Reload Meetings", use_container_width=True):
+            st.session_state.initialized = False
+            st.rerun()
+
+        st.divider()
+
+        st.header("📊 Quick Stats")
+        if st.session_state.rag and st.session_state.initialized:
+            current_filter = st.session_state.get("project_filter")
+
+            if current_filter:
+                st.info(f"Showing: **{current_filter}**")
+                action_items = st.session_state.rag.get_open_action_items(project=current_filter)
+                blockers = st.session_state.rag.get_blockers(project=current_filter)
+            else:
+                projects = st.session_state.rag.get_all_projects()
+                st.metric("Total Projects", len(projects))
+                action_items = st.session_state.rag.get_open_action_items()
+                blockers = st.session_state.rag.get_blockers()
+
+            st.metric("Total Meetings", len(st.session_state.rag.meetings))
+            st.metric("Open Action Items", len(action_items))
+            st.metric("Current Blockers", len(blockers))
+
+        st.divider()
+
+        st.header("💡 Example Queries")
+        st.markdown("""
+        - What are the open action items?
+        - What blockers do we have?
+        - What decisions were made?
+        - What should I focus on next?
+        - Summarize the project status
+        """)
+    
+    # Check HF Token (auto-provided on Spaces, optional locally)
+    if not os.getenv("HF_TOKEN"):
+        st.warning("⚠️ HF_TOKEN not found. Running with limited functionality.")
+        st.info("On Spaces: Token is automatically provided")
+        st.info("Locally: Set HF_TOKEN in .env file (optional for free API)")
+    
+    # Initialize system
+    if not st.session_state.initialized:
+        if not initialize_system():
+            st.warning("No meetings found. Add your meeting notes to get started!")
+            
+            with st.expander("📝 How to add meetings"):
+                st.markdown("""
+                1. Create a folder structure: `data/your_project_name/meetings/`
+                2. Add markdown files with your meeting notes
+                3. Use this format:
+                
+                ```markdown
+                # Meeting: Project Kickoff
+                Date: 2025-01-15
+                Participants: Alice, Bob
+                
+                ## Discussion
+                Your meeting notes here
+                
+                ## Decisions
+                - Decision 1
+                - Decision 2
+                
+                ## Action Items
+                - [ ] Alice: Task 1 by Jan 20
+                - [x] Bob: Task 2 (completed)
+                
+                ## Blockers
+                - Waiting for approval
+                ```
+                """)
+            return
+        
+        st.success(f"Loaded {len(st.session_state.rag.meetings)} meetings!")
+
+    # Main content tabs - ONLY 2 TABS
+    tab1, tab2 = st.tabs(["💬 Chat", "📤 Upload Meeting"])
+
+    with tab1:
+        st.header("💬 Ask Questions About Your Projects")
+
+        # Project selection BEFORE chat
+        if st.session_state.rag and st.session_state.initialized:
+            projects = st.session_state.rag.get_all_projects()
+
+            st.markdown("### Select a Project to Chat About")
+
+            # Create columns for project buttons
+            cols = st.columns(len(projects) + 1)
+
+            # "All Projects" button
+            with cols[0]:
+                if st.button("🌐 All Projects", use_container_width=True, type="secondary"):
+                    st.session_state.selected_chat_project = None
+                    st.rerun()
+
+            # Individual project buttons
+            for i, project in enumerate(projects, 1):
+                with cols[i]:
+                    if st.button(f"📁 {project}", use_container_width=True, type="primary"):
+                        st.session_state.selected_chat_project = project
+                        st.rerun()
+
+            st.divider()
+
+            # Show selected project
+            selected_project = st.session_state.get("selected_chat_project")
+            if selected_project:
+                st.success(f"💬 Chatting about: **{selected_project}**")
+            else:
+                st.info("💬 Chatting about: **All Projects**")
+
+        # Only show chat if a selection has been made
+        if "selected_chat_project" in st.session_state:
+            # Display chat messages
+            for message in st.session_state.messages:
+                with st.chat_message(message["role"]):
+                    st.markdown(message["content"])
+        else:
+            st.warning("👆 Please select a project above to start chatting")
+            return
+
+    # Chat input (must be outside tabs/columns/expanders) - only show if project selected
+    if tab1 and "selected_chat_project" in st.session_state:
+        prompt = st.chat_input("What would you like to know about your projects?")
+
+        # Process chat input
+        if prompt:
+            # Add user message
+            st.session_state.messages.append({"role": "user", "content": prompt})
+            with st.chat_message("user"):
+                st.markdown(prompt)
+
+            # Get agent response with project filter
+            with st.chat_message("assistant"):
+                with st.spinner("Thinking..."):
+                    # Add project context to query if specific project selected
+                    selected_project = st.session_state.get("selected_chat_project")
+                    if selected_project:
+                        enhanced_prompt = f"[Project: {selected_project}] {prompt}"
+                    else:
+                        enhanced_prompt = prompt
+
+                    response = st.session_state.agent.query(enhanced_prompt)
+                    st.markdown(response)
+
+            st.session_state.messages.append({"role": "assistant", "content": response})
+            st.rerun()
+
+    with tab2:
+        st.header("📤 Upload Meeting Notes")
+        st.markdown("Upload plain text meeting notes and let AI structure them for you!")
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            project_name = st.text_input("Project Name", placeholder="e.g., mobile_app_redesign")
+            meeting_date = st.date_input("Meeting Date", value=datetime.now())
+            meeting_title = st.text_input("Meeting Title", placeholder="e.g., Sprint Planning")
+
+        with col2:
+            participants = st.text_input("Participants (comma-separated)", placeholder="e.g., Alice, Bob, Charlie")
+
+        st.markdown("### Paste or Upload Meeting Notes")
+
+        # Option 1: Text area
+        meeting_text = st.text_area(
+            "Paste your meeting notes here (plain text)",
+            height=300,
+            placeholder="""Example:
+We discussed the new feature requirements.
+Alice will implement the login page by next Friday.
+Bob raised a concern about the database migration.
+We decided to use PostgreSQL instead of MySQL.
+Charlie is blocked waiting for API credentials.
+"""
+        )
+
+        # Option 2: File upload
+        uploaded_file = st.file_uploader("Or upload a text file", type=['txt', 'md'])
+
+        if uploaded_file is not None:
+            meeting_text = uploaded_file.read().decode('utf-8')
+            st.info(f"Loaded {len(meeting_text)} characters from file")
+
+        if st.button("🤖 Structure Meeting with AI", type="primary", disabled=not meeting_text or not project_name):
+            with st.spinner("AI is structuring your meeting notes..."):
+                try:
+                    # Use HF Inference API to structure the meeting
+                    endpoint = HuggingFaceEndpoint(
+                        repo_id="meta-llama/Llama-3.2-3B-Instruct",
+                        temperature=0.3,
+                        max_new_tokens=1024,
+                        huggingfacehub_api_token=os.getenv("HF_TOKEN")
+                    )
+                    llm = ChatHuggingFace(llm=endpoint)
+
+                        system_prompt = """You are a meeting notes structuring assistant.
+Convert unstructured meeting notes into a well-formatted markdown document with these sections:
+1. # Meeting: [title]
+2. Date: [date]
+3. Participants: [list]
+4. ## Discussion (key points discussed)
+5. ## Decisions (decisions made)
+6. ## Action Items (as checkboxes with assignee and deadline if mentioned)
+7. ## Blockers (any blockers or issues raised)
+
+Format action items as:
+- [ ] Person: Task description by deadline
+or
+- [ ] Task description (if no person/deadline mentioned)
+
+Extract all relevant information from the raw notes."""
+
+                        user_prompt = f"""Structure these meeting notes:
+
+Raw Notes:
+{meeting_text}
+
+Meeting Details:
+- Title: {meeting_title or 'Meeting'}
+- Date: {meeting_date}
+- Participants: {participants or 'Not specified'}
+"""
+
+                        messages = [
+                            SystemMessage(content=system_prompt),
+                            HumanMessage(content=user_prompt)
+                        ]
+
+                        response = llm.invoke(messages)
+                        structured_md = response.content
+
+                        # Display preview
+                        st.success("✅ Meeting structured successfully!")
+                        st.markdown("### Preview")
+                        st.markdown(structured_md)
+
+                        # Save option
+                        st.markdown("### Save Meeting")
+
+                        save_col1, save_col2 = st.columns([3, 1])
+
+                        with save_col1:
+                            filename = st.text_input(
+                                "Filename",
+                                value=f"{meeting_date.strftime('%Y-%m-%d')}-{meeting_title.lower().replace(' ', '-') if meeting_title else 'meeting'}.md"
+                            )
+
+                        with save_col2:
+                            st.markdown("<br>", unsafe_allow_html=True)
+                            if st.button("💾 Save to Project"):
+                                # Create project directory if needed
+                                project_dir = Path("data") / project_name / "meetings"
+                                project_dir.mkdir(parents=True, exist_ok=True)
+
+                                # Save file
+                                file_path = project_dir / filename
+                                with open(file_path, 'w') as f:
+                                    f.write(structured_md)
+
+                                st.success(f"✅ Saved to `{file_path}`")
+                                st.info("💡 Refresh the page to reload meetings into the RAG system")
+
+                                # Download option
+                                st.download_button(
+                                    label="📥 Download Markdown",
+                                    data=structured_md,
+                                    file_name=filename,
+                                    mime="text/markdown"
+                                )
+
+                except Exception as e:
+                    st.error(f"Error: {str(e)}")
+                    if "quota" in str(e).lower() or "rate" in str(e).lower():
+                        st.warning("⚠️ API rate limit reached. Please wait a moment and try again.")
+
+
+if __name__ == "__main__":
+    main()

data/ai_model_training/meetings/2025-01-10-kickoff.md

@@ -0,0 +1,27 @@
+# Meeting: Project Kickoff - AI Model Training
+Date: 2025-01-10
+Participants: Alice, Bob, Charlie
+
+## Discussion
+We discussed the AI model training project scope and timeline. The goal is to train a new recommendation model using our customer data. We reviewed the current infrastructure and identified gaps in our training pipeline.
+
+Key points:
+- Need to set up new GPU cluster
+- Data preprocessing pipeline needs optimization
+- Model architecture still under discussion (transformer vs CNN)
+
+## Decisions
+- Use PyTorch as the primary framework
+- Deploy on AWS with spot instances for cost savings
+- Weekly sync meetings every Monday at 10 AM
+- Charlie will lead the model architecture design
+
+## Action Items
+- [ ] Alice: Set up GPU cluster by Jan 20
+- [ ] Bob: Optimize data preprocessing pipeline by Jan 25
+- [ ] Charlie: Propose model architecture by Jan 15
+- [ ] Alice: Research spot instance pricing and prepare budget
+
+## Blockers
+- Waiting for budget approval from finance team
+- Need access to production database for training data

data/ai_model_training/meetings/2025-01-17-week2-sync.md

@@ -0,0 +1,25 @@
+# Meeting: Week 2 Sync - AI Model Training
+Date: 2025-01-17
+Participants: Alice, Bob, Charlie, Diana
+
+## Discussion
+Progress update on the AI model training project. Charlie presented the proposed transformer-based architecture which was well-received. Alice reported delays in GPU cluster setup due to procurement issues.
+
+Diana (from finance) joined to discuss budget concerns and approved the spot instance approach which should save 70% on compute costs.
+
+## Decisions
+- Approved: Transformer-based architecture with attention mechanisms
+- Approved: Budget for 6 months of AWS spot instances
+- Use HuggingFace Transformers library for faster development
+- Add Diana to weekly syncs for ongoing budget visibility
+
+## Action Items
+- [x] Charlie: Propose model architecture by Jan 15 (completed)
+- [ ] Alice: Set up GPU cluster by Jan 25 (deadline extended)
+- [ ] Bob: Complete data preprocessing optimization by Jan 25
+- [ ] Charlie: Start initial model implementation by Jan 30
+- [ ] Alice: Document infrastructure setup for team
+
+## Blockers
+- GPU procurement delayed by 2 weeks due to supplier issues
+- Still waiting for production database access credentials

data/mobile_app_redesign/meetings/2025-01-12-design-review.md

@@ -0,0 +1,25 @@
+# Meeting: Design Review - Mobile App Redesign
+Date: 2025-01-12
+Participants: Emma, Frank, Grace
+
+## Discussion
+First design review for the mobile app redesign project. Emma presented the new UI mockups focusing on improving user navigation and reducing cognitive load. The team agreed the new design is cleaner and more intuitive.
+
+We discussed the technical feasibility of implementing the new animations and transitions. Frank raised concerns about performance on older devices.
+
+## Decisions
+- Approved overall design direction
+- Use React Native for cross-platform development
+- Implement progressive enhancement for animations
+- Target iOS 14+ and Android 10+ (drop older OS support)
+- Weekly design reviews every Friday at 2 PM
+
+## Action Items
+- [ ] Emma: Finalize color palette and design system by Jan 19
+- [ ] Frank: Create technical feasibility assessment by Jan 20
+- [ ] Grace: User testing plan for new navigation by Jan 22
+- [ ] Emma: Prepare clickable prototype for stakeholder demo
+
+## Blockers
+- Need stakeholder approval before proceeding to development
+- Waiting for user research data from marketing team

data/mobile_app_redesign/meetings/2025-01-19-stakeholder-demo.md

@@ -0,0 +1,26 @@
+# Meeting: Stakeholder Demo - Mobile App Redesign
+Date: 2025-01-19
+Participants: Emma, Frank, Grace, Henry (CEO), Isabel (Marketing)
+
+## Discussion
+Presented the mobile app redesign to key stakeholders. Henry loved the new design and gave immediate approval to proceed. Isabel shared user research data showing that 80% of users find the current app navigation confusing.
+
+The stakeholders emphasized the importance of launching before the competitor's product release in March. This means we need to accelerate the timeline.
+
+## Decisions
+- Approved: Proceed with redesign implementation
+- Approved: Additional budget for 2 more developers
+- Target launch: End of February (aggressive but feasible)
+- Focus on core features first, nice-to-haves for v2
+- Isabel's team will handle beta testing coordination
+
+## Action Items
+- [x] Emma: Prepare clickable prototype for stakeholder demo (completed)
+- [x] Emma: Finalize color palette and design system (completed)
+- [ ] Frank: Start development sprint planning by Jan 22
+- [ ] Frank: Hire 2 additional React Native developers by Jan 26
+- [ ] Grace: Coordinate with Isabel's team for beta testing by Feb 1
+- [ ] Emma: Create asset library for developers by Jan 24
+
+## Blockers
+- None! Full approval received and budget allocated

demo.py

@@ -0,0 +1,96 @@
+"""
+Demo script to showcase the AI Project Assistant capabilities.
+"""
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+from src.rag import ProjectRAG
+from src.agent import ProjectAgent
+
+# Load environment variables
+load_dotenv()
+
+
+def main():
+    """Run the demo."""
+    print("=" * 60)
+    print("AI Project Assistant - Demo")
+    print("=" * 60)
+    
+    # Check for API key
+    if not os.getenv("GOOGLE_API_KEY"):
+        print("\n⚠️  ERROR: GOOGLE_API_KEY not found!")
+        print("Please create a .env file with your Google API key:")
+        print("  GOOGLE_API_KEY=your_key_here")
+        print("\nGet your API key from: https://aistudio.google.com/apikey")
+        return
+    
+    # Initialize RAG system
+    print("\n📁 Initializing RAG system...")
+    data_dir = Path("./data")
+    rag = ProjectRAG(data_dir)
+    rag.load_and_index()
+    
+    if not rag.meetings:
+        print("\n⚠️  No meetings found!")
+        print("Please add meeting notes to the data directory.")
+        return
+    
+    print(f"✅ Loaded {len(rag.meetings)} meetings")
+    print(f"✅ Projects: {', '.join(rag.get_all_projects())}")
+    
+    # Initialize agent
+    print("\n🤖 Initializing AI Agent...")
+    agent = ProjectAgent(rag)
+    print("✅ Agent ready!")
+    
+    # Demo queries
+    demo_queries = [
+        "What are all the open action items?",
+        "What blockers do we have across all projects?",
+        "What is the status of the AI model training project?",
+        "What should the team focus on next for the mobile app redesign?",
+    ]
+    
+    print("\n" + "=" * 60)
+    print("Running Demo Queries")
+    print("=" * 60)
+    
+    for i, query in enumerate(demo_queries, 1):
+        print(f"\n📝 Query {i}: {query}")
+        print("-" * 60)
+        
+        answer = agent.query(query)
+        print(answer)
+        print()
+    
+    # Interactive mode
+    print("\n" + "=" * 60)
+    print("Interactive Mode - Ask your own questions!")
+    print("(Type 'quit' or 'exit' to end)")
+    print("=" * 60)
+    
+    while True:
+        try:
+            user_query = input("\n💬 Your question: ").strip()
+            
+            if user_query.lower() in ['quit', 'exit', 'q']:
+                print("\n👋 Thanks for using AI Project Assistant!")
+                break
+            
+            if not user_query:
+                continue
+            
+            print("\n🤖 Assistant:", end=" ")
+            answer = agent.query(user_query)
+            print(answer)
+            
+        except KeyboardInterrupt:
+            print("\n\n👋 Thanks for using AI Project Assistant!")
+            break
+        except Exception as e:
+            print(f"\n❌ Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,25 @@
+# Core dependencies
+gradio>=4.0.0
+langchain>=0.3.0
+langchain-community>=0.0.10
+langchain-huggingface>=0.1.0
+langchain-text-splitters>=0.3.0
+
+# Vector store and embeddings
+chromadb>=0.4.22
+sentence-transformers>=2.3.0
+huggingface-hub>=0.20.0
+
+# Agent framework
+langgraph>=0.0.20
+
+# Document processing
+python-dotenv>=1.0.0
+pydantic>=2.5.3
+
+# Utilities
+pyyaml>=6.0.0
+python-dateutil>=2.8.2
+
+# For HF Inference
+transformers>=4.30.0

src/__init__.py

@@ -0,0 +1,12 @@
+"""
+AI Project Assistant - Source package.
+"""
+
+__all__ = [
+    'MeetingNote',
+    'ActionItem',
+    'MeetingParser',
+    'load_meetings_from_directory',
+    'ProjectRAG',
+    'ProjectAgent',
+]

src/agent.py

@@ -0,0 +1,237 @@
+"""
+AI Agent for project management using LangGraph.
+"""
+from typing import TypedDict, Annotated, Sequence, List, Dict, Any
+import operator
+import os
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, SystemMessage
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+from langgraph.graph import StateGraph, END
+from src.rag import ProjectRAG
+
+
+class AgentState(TypedDict):
+    """State for the agent."""
+    messages: Annotated[Sequence[BaseMessage], operator.add]
+    query: str
+    retrieved_context: List[Dict[str, Any]]
+    action_items: List[Dict[str, Any]]
+    blockers: List[Dict[str, Any]]
+    next_step: str
+    final_answer: str
+
+
+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."""
+        self.rag = rag
+        # Use HF Inference API (free tier)
+        llm = HuggingFaceEndpoint(
+            repo_id=model_name,
+            temperature=0.1,
+            max_new_tokens=512,
+            huggingfacehub_api_token=os.getenv("HF_TOKEN")
+        )
+        self.llm = ChatHuggingFace(llm=llm)
+        self.graph = self._build_graph()
+    
+    def _build_graph(self) -> StateGraph:
+        """Build the agent's state graph."""
+        workflow = StateGraph(AgentState)
+        
+        # Add nodes
+        workflow.add_node("analyze_query", self.analyze_query)
+        workflow.add_node("retrieve_context", self.retrieve_context)
+        workflow.add_node("get_action_items", self.get_action_items)
+        workflow.add_node("get_blockers", self.get_blockers)
+        workflow.add_node("generate_answer", self.generate_answer)
+        
+        # Add edges
+        workflow.set_entry_point("analyze_query")
+        workflow.add_edge("analyze_query", "retrieve_context")
+        workflow.add_conditional_edges(
+            "retrieve_context",
+            self.route_after_retrieval,
+            {
+                "action_items": "get_action_items",
+                "blockers": "get_blockers",
+                "answer": "generate_answer"
+            }
+        )
+        workflow.add_edge("get_action_items", "generate_answer")
+        workflow.add_edge("get_blockers", "generate_answer")
+        workflow.add_edge("generate_answer", END)
+        
+        return workflow.compile()
+    
+    def analyze_query(self, state: AgentState) -> AgentState:
+        """Analyze the user's query to understand intent."""
+        query = state["query"]
+        
+        system_prompt = """You are a query analyzer for a project management assistant.
+Analyze queries and determine what information is being requested."""
+
+        analysis_prompt = f"""Analyze this query and determine:
+1. What information is being requested?
+2. Which project (if specified)?
+3. What type of query is this (action items, blockers, status, decisions, general)?
+
+Query: {query}
+
+Respond in this format:
+Type: [action_items|blockers|status|decisions|general]
+Project: [project name or "all"]
+Intent: [brief description]
+"""
+
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=analysis_prompt)
+        ]
+        response = self.llm.invoke(messages)
+        
+        state["messages"] = state.get("messages", []) + [
+            HumanMessage(content=query),
+            AIMessage(content=f"Analysis: {response.content}")
+        ]
+        
+        return state
+    
+    def retrieve_context(self, state: AgentState) -> AgentState:
+        """Retrieve relevant context from the RAG system."""
+        query = state["query"]
+        
+        # Extract project name if mentioned
+        project_filter = None
+        projects = self.rag.get_all_projects()
+        for project in projects:
+            if project.lower() in query.lower():
+                project_filter = project
+                break
+        
+        # Search for relevant context
+        results = self.rag.search(query, n_results=5, project_filter=project_filter)
+        state["retrieved_context"] = results
+        
+        return state
+    
+    def route_after_retrieval(self, state: AgentState) -> str:
+        """Route to appropriate node based on query type."""
+        query = state["query"].lower()
+        
+        if any(term in query for term in ["action item", "todo", "task", "what's next", "what should"]):
+            return "action_items"
+        elif any(term in query for term in ["blocker", "issue", "problem", "stuck"]):
+            return "blockers"
+        else:
+            return "answer"
+    
+    def get_action_items(self, state: AgentState) -> AgentState:
+        """Get action items from the RAG system."""
+        query = state["query"].lower()
+        
+        # Extract project name if mentioned
+        project_filter = None
+        projects = self.rag.get_all_projects()
+        for project in projects:
+            if project.lower() in query:
+                project_filter = project
+                break
+        
+        action_items = self.rag.get_open_action_items(project=project_filter)
+        state["action_items"] = action_items
+        
+        return state
+    
+    def get_blockers(self, state: AgentState) -> AgentState:
+        """Get blockers from the RAG system."""
+        query = state["query"].lower()
+        
+        # Extract project name if mentioned
+        project_filter = None
+        projects = self.rag.get_all_projects()
+        for project in projects:
+            if project.lower() in query:
+                project_filter = project
+                break
+        
+        blockers = self.rag.get_blockers(project=project_filter)
+        state["blockers"] = blockers
+        
+        return state
+    
+    def generate_answer(self, state: AgentState) -> AgentState:
+        """Generate the final answer using retrieved context."""
+        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 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:")
+        ]
+        
+        response = self.llm.invoke(messages)
+        state["final_answer"] = response.content
+        
+        return state
+    
+    def query(self, user_query: str) -> str:
+        """Process a user query and return an answer."""
+        initial_state = {
+            "messages": [],
+            "query": user_query,
+            "retrieved_context": [],
+            "action_items": [],
+            "blockers": [],
+            "next_step": "",
+            "final_answer": ""
+        }
+        
+        result = self.graph.invoke(initial_state)
+        return result["final_answer"]

src/parsers.py

@@ -0,0 +1,215 @@
+"""
+Meeting note parsers for extracting structured data from markdown files.
+"""
+from pathlib import Path
+from typing import List, Optional
+from datetime import datetime
+from pydantic import BaseModel, Field
+import re
+
+
+class ActionItem(BaseModel):
+    """Represents an action item from a meeting."""
+    task: str
+    assignee: Optional[str] = None
+    deadline: Optional[str] = None
+    completed: bool = False
+
+
+class MeetingNote(BaseModel):
+    """Represents a parsed meeting note."""
+    project_name: str
+    title: str
+    date: Optional[datetime] = None
+    participants: List[str] = Field(default_factory=list)
+    discussion: Optional[str] = None
+    decisions: List[str] = Field(default_factory=list)
+    action_items: List[ActionItem] = Field(default_factory=list)
+    blockers: List[str] = Field(default_factory=list)
+    file_path: str
+
+
+class MeetingParser:
+    """Parser for markdown meeting notes."""
+
+    @staticmethod
+    def parse_date(date_str: str) -> Optional[datetime]:
+        """Parse date from various formats."""
+        date_formats = [
+            "%Y-%m-%d",
+            "%d/%m/%Y",
+            "%m/%d/%Y",
+            "%B %d, %Y",
+            "%b %d, %Y",
+            "%Y/%m/%d"
+        ]
+
+        for fmt in date_formats:
+            try:
+                return datetime.strptime(date_str.strip(), fmt)
+            except ValueError:
+                continue
+        return None
+
+    @staticmethod
+    def parse_action_item(line: str) -> Optional[ActionItem]:
+        """Parse an action item line."""
+        # Match patterns like:
+        # - [ ] Task
+        # - [x] Task
+        # - [ ] Alice: Task by Jan 20
+        # - [x] Bob: Task (by 2025-01-20)
+
+        completed = False
+        if "[x]" in line.lower() or "[✓]" in line or "[✔]" in line:
+            completed = True
+
+        # Remove checkbox markers
+        line = re.sub(r'\[[ xX✓✔]\]', '', line).strip()
+        line = line.lstrip('- ').strip()
+
+        if not line:
+            return None
+
+        # Try to extract assignee
+        assignee = None
+        assignee_match = re.match(r'^([A-Za-z\s]+):\s*(.+)$', line)
+        if assignee_match:
+            assignee = assignee_match.group(1).strip()
+            line = assignee_match.group(2).strip()
+
+        # Try to extract deadline
+        deadline = None
+        deadline_patterns = [
+            r'by\s+([A-Za-z]+\s+\d{1,2}(?:,\s+\d{4})?)',
+            r'by\s+(\d{4}-\d{2}-\d{2})',
+            r'\(by\s+([^)]+)\)',
+        ]
+
+        for pattern in deadline_patterns:
+            deadline_match = re.search(pattern, line, re.IGNORECASE)
+            if deadline_match:
+                deadline = deadline_match.group(1).strip()
+                line = re.sub(pattern, '', line, flags=re.IGNORECASE).strip()
+                break
+
+        return ActionItem(
+            task=line,
+            assignee=assignee,
+            deadline=deadline,
+            completed=completed
+        )
+
+    @staticmethod
+    def parse(file_path: Path, project_name: str) -> Optional[MeetingNote]:
+        """Parse a markdown meeting note file."""
+        if not file_path.exists():
+            return None
+
+        content = file_path.read_text(encoding='utf-8')
+        lines = content.split('\n')
+
+        # Initialize fields
+        title = file_path.stem.replace('-', ' ').replace('_', ' ').title()
+        date = None
+        participants = []
+        discussion = []
+        decisions = []
+        action_items = []
+        blockers = []
+
+        current_section = None
+
+        for line in lines:
+            line_stripped = line.strip()
+
+            # Skip empty lines
+            if not line_stripped:
+                continue
+
+            # Check for title
+            if line_stripped.startswith('# '):
+                title = line_stripped[2:].strip()
+                # Try to extract from "Meeting: X" format
+                if title.lower().startswith('meeting:'):
+                    title = title[8:].strip()
+                continue
+
+            # Check for metadata
+            if line_stripped.lower().startswith('date:'):
+                date_str = line_stripped[5:].strip()
+                date = MeetingParser.parse_date(date_str)
+                continue
+
+            if line_stripped.lower().startswith('participants:'):
+                participants_str = line_stripped[13:].strip()
+                participants = [p.strip() for p in participants_str.split(',')]
+                continue
+
+            # Check for sections
+            if line_stripped.startswith('## '):
+                section_name = line_stripped[3:].strip().lower()
+                if 'discussion' in section_name or 'notes' in section_name:
+                    current_section = 'discussion'
+                elif 'decision' in section_name:
+                    current_section = 'decisions'
+                elif 'action' in section_name or 'todo' in section_name or 'task' in section_name:
+                    current_section = 'action_items'
+                elif 'blocker' in section_name or 'issue' in section_name:
+                    current_section = 'blockers'
+                else:
+                    current_section = 'discussion'
+                continue
+
+            # Add content to current section
+            if current_section == 'discussion':
+                discussion.append(line_stripped)
+            elif current_section == 'decisions':
+                if line_stripped.startswith('-') or line_stripped.startswith('*'):
+                    decisions.append(line_stripped.lstrip('-*').strip())
+            elif current_section == 'action_items':
+                if '[' in line_stripped:
+                    action_item = MeetingParser.parse_action_item(line_stripped)
+                    if action_item:
+                        action_items.append(action_item)
+            elif current_section == 'blockers':
+                if line_stripped.startswith('-') or line_stripped.startswith('*'):
+                    blockers.append(line_stripped.lstrip('-*').strip())
+
+        return MeetingNote(
+            project_name=project_name,
+            title=title,
+            date=date,
+            participants=participants,
+            discussion='\n'.join(discussion) if discussion else None,
+            decisions=decisions,
+            action_items=action_items,
+            blockers=blockers,
+            file_path=str(file_path)
+        )
+
+
+def load_meetings_from_directory(data_dir: Path) -> List[MeetingNote]:
+    """Load all meeting notes from a directory structure."""
+    meetings = []
+
+    if not data_dir.exists():
+        return meetings
+
+    # Expected structure: data_dir/project_name/meetings/*.md
+    for project_dir in data_dir.iterdir():
+        if not project_dir.is_dir():
+            continue
+
+        project_name = project_dir.name
+        meetings_dir = project_dir / "meetings"
+
+        if not meetings_dir.exists():
+            continue
+
+        for meeting_file in meetings_dir.glob("*.md"):
+            meeting = MeetingParser.parse(meeting_file, project_name)
+            if meeting:
+                meetings.append(meeting)
+
+    return meetings

src/rag.py

@@ -0,0 +1,216 @@
+"""
+RAG (Retrieval Augmented Generation) implementation for project assistant.
+"""
+from pathlib import Path
+from typing import List, Dict, Any
+from datetime import datetime
+import chromadb
+from chromadb.config import Settings
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from src.parsers import MeetingNote, load_meetings_from_directory
+
+
+class ProjectRAG:
+    """RAG system for project meeting notes."""
+    
+    def __init__(self, data_dir: Path, persist_dir: Path = None):
+        """Initialize the RAG system."""
+        self.data_dir = data_dir
+        self.persist_dir = persist_dir or Path("./chroma_db")
+        
+        # Initialize embeddings
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name="sentence-transformers/all-MiniLM-L6-v2"
+        )
+        
+        # Initialize ChromaDB
+        self.client = chromadb.PersistentClient(path=str(self.persist_dir))
+        self.collection = self.client.get_or_create_collection(
+            name="meeting_notes",
+            metadata={"hnsw:space": "cosine"}
+        )
+        
+        # Text splitter for chunking
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=500,
+            chunk_overlap=50,
+            separators=["\n\n", "\n", ". ", " ", ""]
+        )
+        
+        self.meetings: List[MeetingNote] = []
+    
+    def load_and_index(self):
+        """Load all meetings and index them in the vector store."""
+        print("Loading meetings from directory...")
+        self.meetings = load_meetings_from_directory(self.data_dir)
+        print(f"Loaded {len(self.meetings)} meetings")
+        
+        if not self.meetings:
+            print("No meetings found. Please add meeting notes to the data directory.")
+            return
+        
+        # Clear existing collection
+        self.client.delete_collection("meeting_notes")
+        self.collection = self.client.create_collection(
+            name="meeting_notes",
+            metadata={"hnsw:space": "cosine"}
+        )
+        
+        print("Indexing meetings...")
+        documents = []
+        metadatas = []
+        ids = []
+        
+        for idx, meeting in enumerate(self.meetings):
+            # Create a rich document representation
+            doc_parts = [
+                f"Project: {meeting.project_name}",
+                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"Discussion:\n{meeting.discussion}")
+            
+            if meeting.decisions:
+                doc_parts.append("Decisions:")
+                doc_parts.extend([f"- {d}" for d in meeting.decisions])
+            
+            if meeting.action_items:
+                doc_parts.append("Action Items:")
+                for item in meeting.action_items:
+                    status = "✓" 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("Blockers:")
+                doc_parts.extend([f"- {b}" for b in meeting.blockers])
+            
+            full_doc = "\n".join(doc_parts)
+            
+            # Chunk the document
+            chunks = self.text_splitter.split_text(full_doc)
+            
+            for chunk_idx, chunk in enumerate(chunks):
+                documents.append(chunk)
+                metadatas.append({
+                    "meeting_idx": idx,
+                    "project": meeting.project_name,
+                    "title": meeting.title,
+                    "date": meeting.date.isoformat() if meeting.date else "",
+                    "file_path": meeting.file_path,
+                    "chunk_idx": chunk_idx
+                })
+                ids.append(f"meeting_{idx}_chunk_{chunk_idx}")
+        
+        # Add to ChromaDB
+        if documents:
+            # Embed documents
+            embeddings_list = self.embeddings.embed_documents(documents)
+            
+            self.collection.add(
+                embeddings=embeddings_list,
+                documents=documents,
+                metadatas=metadatas,
+                ids=ids
+            )
+            print(f"Indexed {len(documents)} chunks from {len(self.meetings)} meetings")
+    
+    def search(self, query: str, n_results: int = 5, project_filter: str = None) -> List[Dict[str, Any]]:
+        """Search for relevant meeting content."""
+        # Embed the query
+        query_embedding = self.embeddings.embed_query(query)
+        
+        # Prepare where clause for filtering
+        where = None
+        if project_filter:
+            where = {"project": project_filter}
+        
+        # Search in ChromaDB
+        results = self.collection.query(
+            query_embeddings=[query_embedding],
+            n_results=n_results,
+            where=where
+        )
+        
+        # Format results
+        formatted_results = []
+        if results['documents'] and results['documents'][0]:
+            for i in range(len(results['documents'][0])):
+                formatted_results.append({
+                    'content': results['documents'][0][i],
+                    'metadata': results['metadatas'][0][i],
+                    'distance': results['distances'][0][i] if 'distances' in results else None
+                })
+        
+        return formatted_results
+    
+    def get_all_projects(self) -> List[str]:
+        """Get list of all project names."""
+        return list(set(m.project_name for m in self.meetings))
+    
+    def get_open_action_items(self, project: str = None) -> List[Dict[str, Any]]:
+        """Get all open action items, optionally filtered by project."""
+        action_items = []
+        
+        for meeting in self.meetings:
+            if project and meeting.project_name != project:
+                continue
+            
+            for item in meeting.action_items:
+                if not item.completed:
+                    action_items.append({
+                        'project': meeting.project_name,
+                        'meeting': meeting.title,
+                        'date': meeting.date,
+                        'assignee': item.assignee,
+                        'task': item.task,
+                        'deadline': item.deadline
+                    })
+        
+        return action_items
+    
+    def get_blockers(self, project: str = None) -> List[Dict[str, Any]]:
+        """Get all blockers, optionally filtered by project."""
+        blockers = []
+        
+        for meeting in self.meetings:
+            if project and meeting.project_name != project:
+                continue
+            
+            for blocker in meeting.blockers:
+                blockers.append({
+                    'project': meeting.project_name,
+                    'meeting': meeting.title,
+                    'date': meeting.date,
+                    'blocker': blocker
+                })
+        
+        return blockers
+    
+    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,
+                    'meeting': meeting.title,
+                    'date': meeting.date,
+                    'decision': decision
+                })
+                
+                if len(decisions) >= limit:
+                    return decisions
+        
+        return decisions

src/utils.py

@@ -0,0 +1,97 @@
+"""
+Utility functions for the project assistant.
+"""
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Any
+
+
+def format_date(date: datetime) -> str:
+    """Format a datetime object for display."""
+    if date is None:
+        return "Unknown date"
+    return date.strftime("%B %d, %Y")
+
+
+def format_action_item(item: Dict[str, Any]) -> str:
+    """Format an action item for display."""
+    parts = []
+    
+    if item.get('assignee'):
+        parts.append(f"**{item['assignee']}**:")
+    
+    parts.append(item['task'])
+    
+    if item.get('deadline'):
+        parts.append(f"(by {item['deadline']})")
+    
+    return " ".join(parts)
+
+
+def get_project_stats(meetings: List[Any]) -> Dict[str, Any]:
+    """Calculate statistics across all projects."""
+    stats = {
+        'total_meetings': len(meetings),
+        'total_action_items': 0,
+        'completed_action_items': 0,
+        'open_action_items': 0,
+        'total_blockers': 0,
+        'total_decisions': 0,
+        'projects': {}
+    }
+    
+    for meeting in meetings:
+        project = meeting.project_name
+        
+        if project not in stats['projects']:
+            stats['projects'][project] = {
+                'meetings': 0,
+                'action_items': 0,
+                'blockers': 0,
+                'decisions': 0
+            }
+        
+        stats['projects'][project]['meetings'] += 1
+        
+        for item in meeting.action_items:
+            stats['total_action_items'] += 1
+            stats['projects'][project]['action_items'] += 1
+            
+            if item.completed:
+                stats['completed_action_items'] += 1
+            else:
+                stats['open_action_items'] += 1
+        
+        stats['total_blockers'] += len(meeting.blockers)
+        stats['projects'][project]['blockers'] += len(meeting.blockers)
+        
+        stats['total_decisions'] += len(meeting.decisions)
+        stats['projects'][project]['decisions'] += len(meeting.decisions)
+    
+    return stats
+
+
+def create_sample_meeting(project_name: str, output_path: Path) -> None:
+    """Create a sample meeting note template."""
+    template = f"""# Meeting: [Meeting Title]
+Date: {datetime.now().strftime('%Y-%m-%d')}
+Participants: [Name1, Name2, Name3]
+
+## Discussion
+[What was discussed in the meeting]
+
+## Decisions
+- [Decision 1]
+- [Decision 2]
+
+## Action Items
+- [ ] [Person]: [Task description] by [deadline]
+- [ ] [Person]: [Task description]
+
+## Blockers
+- [Blocker description]
+"""
+    
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(template)
+    print(f"Created sample meeting template at {output_path}")