TaskBot

TaskBot is an assistant that turns scattered work content into structured tasks: title, assignee, deadline, and priority. It normalizes dates, detects conflicts across sources, and stores everything.

Comment

Inspiration

Deadlines and important tasks often get buried among hundreds of emails, Google Drive files, and attachments—there’s no single place to see the big picture of your work. We want to build an assistant that can automatically parse these disparate data sources (Gmail, Drive, uploaded files) and turn them into clearly structured tasks: who’s doing what, by when, and with what priority—instead of forcing users to manually sort through them.

What it does

TaskBot connects to Gmail and Google Drive, automatically syncs according to a schedule (or on demand), and then runs a multi-stage AI pipeline to:

  • Extract tasks (title, assignee, deadline, priority) from email/document content
  • Standardize dates and data formats
  • Detect conflicts between sources (e.g., two different deadlines for the same deliverable) and allow users to choose between Source A or B, or ignore the conflict
  • Merge (deduplicate) duplicate tasks from the same email thread or file, based on deduplication groups and fuzzy title matching (fuzzy title)
  • Accept uploaded files (PDF/DOCX) and process them through the same pipeline
  • Sync events with Google Calendar when configured
  • Display everything in a single Next.js dashboard for users to confirm or edit tasks ## How we built it The architecture consists of the following layers:
  • Frontend: Next.js 14 + Tailwind for the user dashboard
  • API: FastAPI with Pydantic v2, JWT authentication after logging in via Google OAuth
  • AI pipeline: LangGraph coordinates the sequence of steps: parse → extract → normalize → validate/conflict-check → persist, running on Groq (Llama 3.3 70B as the primary model, automatically falling back to the 8B version when rate-limited)
  • Data: PostgreSQL (managing migrations with Alembic) for long-term storage; Redis for job queues, job storage, and caching
  • Google integration: Communication via MCP (Model Context Protocol) over HTTP — Gmail and Calendar use pre-hosted MCP servers, while Drive uses a custom MCP server in the repo (drive-mcp-server)
  • Deployment: The entire system (Postgres, Redis, MCP Drive, backend, agent, frontend) is packaged using Docker Compose to run end-to-end with a single command

In parallel, the team built a custom evaluation suite (tests/eval/) with a labeled dataset to compare a rule-based baseline, a single-LLM baseline, and the full pipeline, measured using metrics like F1 score and generating Markdown reports—to provide quantitative evidence on whether a multi-step pipeline is truly better than simpler approaches.

Challenges we ran into

  • Design a multi-stage pipeline (LangGraph) stable enough to handle “dirty” and inconsistent data from real-world emails and documents, rather than one that only performs well on sample data
  • Handle LLM rate limits (Groq) while ensuring the pipeline remains uninterrupted—requiring the design of a fallback mechanism between the two models
  • Detect conflicts between multiple information sources for the same task, and design a UI that allows users to resolve conflicts intuitively rather than simply reporting errors
  • Accurately merge duplicate tasks when titles are not exactly the same (fuzzy matching) without mistakenly merging different tasks
  • Integrating multiple MCP servers (Gmail, Calendar, and a custom-built Drive) within a single agent and ensuring the synchronization flow (scheduler + Redis queue) operates reliably ## Accomplishments that we're proud of
  • A production-ready pipeline that runs end-to-end from raw data sources to validated tasks in the dashboard, neatly packaged using Docker Compose
  • Built a framework for repeatable evaluation using a labeled dataset and comparing multiple baselines—something not every AI project takes seriously
  • A conflict detection and deduplication mechanism that works in practice, not just on paper Successfully integrated multiple data sources (Gmail, Drive, file uploads, Calendar) through a unified MCP architecture ## What we learned
  • How to orchestrate a multi-step pipeline using LangGraph and design validation and conflict-check points between steps to prevent error propagation
  • The value of quantitative metrics (F1-style metrics) before claiming that an AI pipeline is “better” than a simpler approach
  • How to design a system that can handle LLM provider rate limits using a model fallback strategy
  • Real-world experience working with MCP to integrate external services (Gmail, Drive, Calendar) into a single agent ## What's next for TaskBot
  • Expand data sources (e.g., Slack, Microsoft Teams, Outlook) beyond Gmail/Drive
  • Improve task extraction accuracy through additional training and fine-tuning based on the existing evaluation dataset
  • Build a mobile app or browser extension to receive real-time notifications about deadlines and conflicts
  • Add the ability to automatically assign tasks to individual team members based on their current workload

Built With

Share this project:

Updates