DEV Community: Sonu Singh

Automate Your Gmail Like a Pro: Creating an AI-Powered Email Assistant

Sonu Singh — Fri, 18 Apr 2025 08:51:13 +0000

Building a Smart Email Assistant with Streamlit, Langchain, and Gmail API

Managing your email inbox can be overwhelming, especially when dealing with hundreds of unread messages, marketing emails, and newsletters. What if you had an AI-powered assistant that could help you summarize, clean, categorize, and even create filters for your Gmail inbox? In this blog post, I’ll walk you through a project that does exactly that — a Smart Email Assistant built using Streamlit, Langchain, and the Google Gmail API.

Project Overview

This Smart Email Assistant is a Streamlit-based web app that leverages Langchain AI agents to interact with your Gmail account. It uses advanced AI models from OpenAI or Google Gemini to understand your commands and perform tasks such as:

Summarizing unread emails
Cleaning up marketing emails older than 30 days
Auto-categorizing emails into Promotions, Work, and Personal folders
Creating Gmail filters automatically
Finding and managing unsubscribe links in newsletters

The assistant provides an interactive chat interface where you can type your requests or use quick action buttons for common tasks.

Key Technologies

Streamlit: For building the user-friendly web interface.
Langchain: To create AI agents that understand and execute natural language commands.
Google Gmail API: To securely access and manage your Gmail inbox.
OpenAI / Google Gemini: AI models powering the assistant’s understanding and responses.
OAuth2 Authentication: Ensures secure access to your Gmail account.

How It Works

The app initializes an AI agent that loads Gmail tools for reading, modifying, and sending emails. It uses OAuth2 to authenticate with Gmail securely. The Streamlit UI maintains chat history and provides quick action buttons for tasks like summarizing unread emails or cleaning marketing emails.

When you enter a command or click a quick action, the agent processes the request using Langchain’s structured chat agent and interacts with Gmail via the API to perform the task.

Setup and Running

Clone the repository and navigate to the project directory.
Create and activate a Python virtual environment.
Install dependencies from requirements.txt.
Set up your Google API credentials by placing your OAuth client secrets file as credentials.json.
Optionally, create a .env file with your Google API key to use Google Gemini.
Run the app with:

   streamlit run app.py

Key Code Snippets

Initializing the Agent (agent.py)

import os
from dotenv import load_dotenv
from langchain.callbacks.streamlit import StreamlitCallbackHandler
from langchain.agents import initialize_agent, AgentType
from langchain.memory import ConversationBufferMemory
from utils import get_all_tools

load_dotenv()

def get_agent(parent_container):
    if os.getenv("GOOGLE_API_KEY"):
        from langchain_google_genai import ChatGoogleGenerativeAI
        llm = ChatGoogleGenerativeAI(
            model="gemini-2.0-flash",
            temperature=0,
            google_api_key=os.getenv("GOOGLE_API_KEY"),
            streaming=True,
            callbacks=[StreamlitCallbackHandler(parent_container=parent_container)],
        )
    else:
        from langchain_openai import ChatOpenAI
        llm = ChatOpenAI(
            temperature=0,
            streaming=True,
            callbacks=[StreamlitCallbackHandler(parent_container=parent_container)],
        )

    tools = get_all_tools()
    memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

    agent = initialize_agent(
        tools,
        llm,
        agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
        verbose=True,
        memory=memory,
    )

    return agent

Streamlit App Main (app.py)

import streamlit as st
from agent import get_agent

st.set_page_config(page_title="Smart Email Assistant", layout="wide")

if "messages" not in st.session_state:
    st.session_state.messages = []
if "agent_initialized" not in st.session_state:
    st.session_state.agent_initialized = False

st.title("Smart Email Assistant")

thinking_container = st.container()

if not st.session_state.agent_initialized:
    with st.spinner("Initializing agent..."):
        st.session_state.agent = get_agent(thinking_container)
        st.session_state.agent_initialized = True

def process_input(query):
    if query:
        st.session_state.messages.append(("user", query))
        with thinking_container:
            response = st.session_state.agent.run(query)
        st.session_state.messages.append(("assistant", response))

user_input = st.chat_input("Type your message here...", key="user_input")

if user_input:
    process_input(user_input)
    st.rerun()

Future Enhancements

Some exciting future scopes for this project include:

Adding a tool to automatically click unsubscribe buttons in newsletters.
Enhancing email categorization with machine learning.
Implementing smart reply suggestions.
Integrating calendar and task management features.
Supporting multiple email providers beyond Gmail.
Improving natural language understanding for complex commands.

Conclusion

This Smart Email Assistant project showcases how AI and automation can simplify email management. By combining Streamlit’s ease of use, Langchain’s powerful AI agents, and the Gmail API, you can build a personalized assistant to keep your inbox organized and manageable.

Feel free to check out the project on GitHub and try it yourself!

GitHub Repository: https://github.com/sonu2164/smart-email-assistant/

Building a Note/Thought Sharing WebApp with OPAL Authorization and Custom MySQL Fetcher

Sonu Singh — Thu, 20 Jun 2024 10:37:06 +0000

Integrating authorization using OPA (Open Policy Agent) with a custom MySQL fetcher in a Node.js Express application, and consuming it with a React frontend, involves several steps. Here’s a detailed walkthrough that covers setting up the backend, Docker environment, and frontend interactions. Below, I'll structure the blog and include all the necessary components you requested.

Goal: Implementing Authorization with OPA and Custom MySQL Fetcher

In this tutorial, we'll set up a Node.js Express backend with JWT authentication and OPA for authorization, utilizing a custom MySQL fetcher. Our frontend, built with React, will interact with this backend to perform CRUD operations on notes.

Prerequisites

Before we begin, make sure you have:

Node.js and npm installed
Docker installed (for local development environment setup)
Basic knowledge of React and Node.js

1. Setting up the Backend

Docker Compose Configuration (`docker-compose.yml`)

version: "3.8"
services:
  broadcast_channel:
    image: postgres
    environment:
      - POSTGRES_DB=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres

  adminer:
    image: adminer
    restart: always
    ports:
      - 8083:8080

  example_db:
    image: mysql:8.0
    cap_add:
      - SYS_NICE
    restart: always
    environment:
      - MYSQL_DATABASE=test
      - MYSQL_USER=test
      - MYSQL_PASSWORD=mysql
      - MYSQL_ROOT_PASSWORD=mysql
    logging:
      options:
        max-size: 10m
        max-file: "3"
    ports:
      - "3306:3306"
    volumes:
      - ./sql/init.sql:/docker-entrypoint-initdb.d/init.sql

  opal_server:
    image: permitio/opal-server
    environment:
      - OPAL_BROADCAST_URI=postgres://postgres@broadcast_channel:5432/postgres
      - UVICORN_NUM_WORKERS=4
      - OPAL_POLICY_REPO_URL=https://github.com/sonu2164/opal-example-policy-repo
      - OPAL_POLICY_REPO_POLLING_INTERVAL=30
      - OPAL_DATA_CONFIG_SOURCES={"config":{"entries":[{"url":"mysql://root@example_db:3306/test?password=mysql","config":{"fetcher":"MySQLFetchProvider","query":"SELECT * FROM users","connection_params":{"host":"example_db","user":"root","port":3306,"db":"test","password":"mysql"}},"topics":["mysql"],"dst_path":"users"},{"url":"mysql://root@example_db:3306/test?password=mysql","config":{"fetcher":"MySQLFetchProvider","query":"SELECT * FROM notes","connection_params":{"host":"example_db","user":"root","port":3306,"db":"test","password":"mysql"}},"topics":["mysql"],"dst_path":"notes"}]}}
    ports:
      - "7002:7002"
    depends_on:
      - broadcast_channel

  opal_client:
    build:
      context: .
    environment:
      - OPAL_SERVER_URL=http://opal_server:7002
      - OPAL_LOG_FORMAT_INCLUDE_PID=true
      - OPAL_FETCH_PROVIDER_MODULES=opal_common.fetcher.providers,opal_fetcher_mysql.provider
      - OPAL_INLINE_OPA_LOG_FORMAT=http
      - OPA_LOG_LEVEL=debug
      - OPAL_SHOULD_REPORT_ON_DATA_UPDATES=True
      - OPAL_DATA_TOPICS=mysql
    ports:
      - "7766:7000"
      - "8181:8181"
    depends_on:
      - opal_server
      - example_db
    command: sh -c "./wait-for.sh opal_server:7002 example_db:3306 --timeout=20 -- ./start.sh"

Explanation:

Sets up PostgreSQL and MySQL databases for storage (broadcast_channel and example_db).
Initializes Opal Server (opal_server) with configurations to connect to PostgreSQL and MySQL databases.
Deploys Opal Client (opal_client) and connects it to Opal Server and MySQL database.

2. Backend Application (`server/index.js`)

const express = require("express");
const axios = require("axios");
const cors = require("cors");
const updateOpaData = require("./src/updata_opa_data").updateOpaData;
const noteshandler = require("./src/noteshandler");
const userhandler = require("./src/userhandler");
const app = express();
const port = 3001;
const { PrismaClient } = require("@prisma/client");
const prisma = new PrismaClient();

const jwt = require('jsonwebtoken');

app.use(express.json());
app.use(cors());

// Authentication middleware
const authenticate = async (req, res, next) => {
  const authHeader = req.headers.authorization;

  if (!authHeader) {
    return res.status(401).json({ error: 'Authorization header missing' });
  }

  const token = authHeader.split(' ')[1]; // Bearer <token>

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    const user = await prisma.user.findUnique({
      where: {
        id: decoded.userId,
      },
    });

    if (!user) {
      return res.status(401).json({ error: 'User not found' });
    }

    req.user = user;
    next();
  } catch (error) {
    console.error('JWT Verification Error:', error);
    return res.status(401).json({ error: 'Invalid or expired token' });
  }
};

// Authorization middleware
const authorization = async (req, res, next) => {
  try {
    const userId = parseInt(req.user.id);
    const noteId = parseInt(req.body.noteId);

    const check = await axios.post(
      "http://localhost:8181/v1/data/app/rbac/allow",
      {
        input: {
          user: userId,
          note: noteId,
        },
      }
    );

    if (check.data.result) {
      next(); // Proceed to the next middleware or route handler
    } else {
      res.status(403).json({ message: "Unauthorized" });
    }
  } catch (error) {
    console.error("Error during authorization check:", error);
    res.status(500).json({ message: "Internal Server Error" });
  }
};

// Routes
app.get("/", (req, res) => {
  res.send("Hello World!");
});

app.post("/user/login", async (req, res) => {
  const { email, password } = req.body;
  const user = await userhandler.loginUser(email, password);
  return res.status(200).json(user);
});

app.post("/user/register", async (req, res) => {
  const { name, email, password, role } = req.body
  const user = await userhandler.registerUser(name, email, password, role);
  await updateOpaData();
  return res.status(200).json(user);
});

app.get("/notes", async (req, res) => {
  const notes = await noteshandler.notes();
  return res.status(200).json(notes);
});

app.post("/newNote", authenticate, async (req, res) => {
  const noteObj = {
    title: req.body.title,
    description: req.body.description,
    user: { connect: { id: req.user.id } },
  };

  try {
    const note = await noteshandler.newNote(noteObj);
    await updateOpaData(); // Update OPA data after creating a new note
    return res.status(200).json(note);
  } catch (error) {
    console.error("Error creating new note:", error);
    return res.status(500).json({ message: "Internal Server Error" });
  }
});

app.post("/note/update", authenticate, authorization, async (req, res) => {
  const { noteId, title, description } = req.body;

  try {
    const note = await noteshandler.updateNote(noteId, title, description);
    await updateOpaData(); // Update OPA data after updating a note
    return res.status(200).json(note);
  } catch (error) {
    console.error("Error updating note:", error);
    return res.status(500).json({ message: "Internal Server Error" });
  }
});

app.post("/note/delete", authenticate, authorization, async (req, res) => {
  const { noteId } = req.body;
  try {
    const delRes = await noteshandler.deleteNote(noteId);
    await updateOpaData(); // Update OPA data after deleting a note
    return res.status(200).json({ status: delRes });
  } catch (error) {
    console.error("Error deleting note:", error);
    return res.status(500).json({ message: "Internal Server Error" });
  }
});

app.listen(port, () => {
  console.log(`App server listening on port ${port}`);
});