Meeting Mind 🎙️🧠

An intelligent, stateful agent designed to analyze meeting transcripts, extract key information, and answer questions. Powered by LangGraph and Google Gemini, this application provides conversational insights into your meeting data, with all conversations and audio persistently stored for seamless access.

---

🖼️ Application UI

The app features a clean, interactive Streamlit interface where users can upload meeting audio, view transcriptions, and interact with the AI agent to get summaries, action items, and more.

---

✨ Overview

Meeting Mind is designed to streamline the post-meeting analysis process. Instead of manually sifting through hours of recordings or notes, users can upload audio transcripts and query an intelligent agent to quickly retrieve specific information, understand key outcomes, and identify next steps.

The app architecture leverages:

• LangGraph for stateful, multi-step conversational workflows.
• Streamlit for the interactive and user-friendly web interface.
• SQLite for persistent storage of conversation history and meeting metadata (transcripts, audio file paths).
• Google Gemini 2.5 Pro for powerful natural language understanding, transcription, summarization, and information extraction.
• Faster Whisper for efficient and accurate audio transcription.

---

⚙️ How It Works

The agent follows a sophisticated LangGraph flow to process meeting audio and answer user queries:

1. Audio Upload & Transcription: Users upload meeting audio files. Faster Whisper transcribes the audio, and an LLM generates a descriptive title for the conversation.
2. Conversation Persistence: The transcription, audio file path, and conversation title are stored in a SQLite database, along with LangGraph's checkpoints, ensuring session continuity.
3. User Query & Intent Routing: When a user asks a question, the agent's initial node (analyze_node) analyzes the full conversation history to determine the user's intent (e.g., requesting a summary, action items, specific details).
4. Specialized Node Execution: Based on the detected intent, the graph routes the conversation to a specific analytical node:
   • summarize_meeting_node: Provides an overall meeting summary.
   • extract_action_items_node: Identifies and lists action items.
   • extract_decisions_node: Extracts key decisions made.
   • find_persons_node: Lists all mentioned persons.
   • identify_topics_node: Highlights main discussion topics.
   • generate_questions_node: Suggests follow-up questions.
   • answer_node: Handles general questions by directly querying the transcript.
5. Answer Synthesis: The results from the specialized nodes (which return ToolMessages) are then passed to a central answer_node. This node uses another LLM to synthesize these raw outputs, along with the full conversation history and transcription, into a natural, user-friendly AIMessage.
6. Display & Iteration: The final AIMessage is displayed in the Streamlit UI, allowing for multi-turn, context-aware interaction.

---

🧠 Graph Architecture

The architecture relies on a dynamic, intent-driven graph built with LangGraph. It features a central routing mechanism (analyze_node) that directs queries to specialized analytical nodes, ensuring efficient and targeted processing. All analytical nodes then feed into a final synthesis node (answer_node) for polished responses.

---

🚀 Key Features

• Intelligent Meeting Analysis: Get summaries, action items, decisions, person mentions, and key topics from meeting transcripts.
• Context-Aware Conversational AI: The agent understands intent based on full chat history for accurate routing.
• Persistent Chat Memory: All conversations, including audio file paths and transcripts, are saved in a local SQLite database for seamless continuity across sessions.
• Efficient Audio Transcription: Utilizes Faster Whisper for fast and accurate speech-to-text.
• Dynamic LangGraph Routing: Employs structured LLM outputs for robust routing to specialized analysis functions.
• Interactive Streamlit UI: Provides a clean and easy-to-use interface for uploading audio and interacting with the agent.

---

🛠️ Tech Stack

• Orchestration: LangChain & LangGraph
• LLM: Google Gemini (gemini-2.5-pro)
• Transcription: Faster Whisper (base model)
• Database: SQLite (db.sqlite)
• UI Framework: Streamlit
• Environment Management: Python venv or Docker

---

📦 Setup & Installation

Option 1: Run Locally (venv)

1. Clone the Repository

   git clone https://github.com/eslammohamedtolba/MeetingMind.git
   cd MeetingMind

2. Create and Activate a Virtual Environment

   # Create the environment
   python -m venv venv
   
   # Activate on Windows PowerShell
   .\venv\Scripts\Activate.ps1
   
   # On macOS/Linux
   source venv/bin/activate

3. Install Dependencies

   pip install -r requirements.txt

4. Add Environment Variables

   • Create a .env file in the root directory and add:

     GOOGLE_API_KEY="YOUR_GOOGLE_API_KEY"

5. Launch the App

   streamlit run app/main.py

6. Access the App Open http://localhost:8501 in your browser and start analyzing your meetings!

---

Option 2: Run with Docker

1. Ensure Docker is Running

2. Build the Docker Image

   docker build -t meeting-mind-app .

3. Run the Container

   docker run -p 8501:8501 \
     -v "$(pwd)/db.sqlite:/app/db.sqlite" \
     -v "$(pwd)/audio_files:/app/audio_files" \
     -v "$(pwd)/.env:/app/.env" \
     --name meeting-mind-container \
     meeting-mind-app

   Explanation:

   • -p 8501:8501: Maps Streamlit's internal port to your host machine.
   • -v ...: Mounts your local db.sqlite, audio_files directory, and .env file into the container, ensuring data persistence and environment variable loading.
   • --name meeting-mind-container: Assigns a readable name to your running container.

4. Access the Application Go to: http://localhost:8501

5. Stop the Container

   docker stop meeting-mind-container

6. (Optional) Remove the Container

   docker rm meeting-mind-container

---

🤝 Contributing

We welcome contributions! Feel free to fork this repo, open issues, or submit pull requests to enhance functionality, add new analytical tools, or improve performance.