Multilingual Google Meet Summarizer and Python Project

A Multilingual Google Meet Summarizer is a Chrome extension that automatically transcribes and summarizes Google Meet conversations in multiple languages. This tool became especially valuable during remote work periods when effective meeting documentation was crucial for productivity.

In this article, we'll explore the project architecture and examine key implementation details using Python for natural language processing and summarization.

Project Overview

This Chrome extension captures audio from Google Meet sessions, generates transcriptions, and creates summarized versions in various languages. The system combines web technologies with machine learning for intelligent text processing.

Technology Stack

• Frontend ? React.js, HTML, CSS, Bootstrap

• Backend ? Django REST Framework

• Machine Learning ? PyTorch, NLTK, Google Translate API

• Database ? SQLite

System Architecture

The application follows this workflow ?

• User starts Google Meet and enables the extension

• Extension captures audio and converts speech to text

• Transcribed text is sent to Django backend for processing

• ML algorithms summarize and translate the content

• Processed transcription is available for download

Language Translation Implementation

The translation module supports multiple languages using Google Translate API ?

from googletrans import Translator

LANG_CODES = {
    'ENGLISH': 'en',
    'HINDI': 'hi',
    'MARATHI': 'mr',
    'ARABIC': 'ar',
    'BENGALI': 'bn',
    'CHINESE': 'zh-CN',
    'FRENCH': 'fr',
    'GUJARATI': 'gu',
    'JAPANESE': 'ja',
    'KANNADA': 'kn',
    'MALAYALAM': 'ml',
    'NEPALI': 'ne',
    'PORTUGUESE': 'pt',
    'PUNJABI': 'pa',
    'RUSSIAN': 'ru',
    'SPANISH': 'es',
    'TAMIL': 'ta',
    'TELUGU': 'te',
    'URDU': 'ur'
}

def language_translate(input_data, input_lang, output_lang):
    input_lang, output_lang = input_lang.upper(), output_lang.upper()
    translator = Translator()
    
    translated_text = translator.translate(
        input_data, 
        src=LANG_CODES[input_lang], 
        dest=LANG_CODES[output_lang]
    )
    
    return translated_text.text

# Example usage
text = "Hello, how are you today?"
result = language_translate(text, "english", "hindi")
print(f"Translated: {result}")

Text Summarization Algorithm

The summarization process uses frequencybased sentence ranking to extract key information ?

import nltk
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.corpus import stopwords

# Download required NLTK data
nltk.download('stopwords', quiet=True)
nltk.download('punkt', quiet=True)

stop_words = set(stopwords.words("english"))

def create_frequency_table(text):
    """Create word frequency table excluding stopwords"""
    words = word_tokenize(text.lower())
    frequency_table = {}
    
    for word in words:
        if word not in stop_words and word.isalnum():
            frequency_table[word] = frequency_table.get(word, 0) + 1
    
    return frequency_table

def score_sentences(text):
    """Score sentences based on word frequencies"""
    sentences = sent_tokenize(text)
    frequency_table = create_frequency_table(text)
    sentence_scores = {}
    
    for sentence in sentences:
        words = word_tokenize(sentence.lower())
        score = 0
        word_count = 0
        
        for word in words:
            if word in frequency_table:
                score += frequency_table[word]
                word_count += 1
        
        if word_count > 0:
            sentence_scores[sentence] = score / word_count
    
    return sentence_scores

def generate_summary(text, num_sentences=3):
    """Generate summary by selecting top-scored sentences"""
    sentence_scores = score_sentences(text)
    
    # Sort sentences by score
    ranked_sentences = sorted(sentence_scores.items(), 
                            key=lambda x: x[1], reverse=True)
    
    # Select top sentences
    selected_sentences = [sent[0] for sent in ranked_sentences[:num_sentences]]
    
    # Maintain original order
    sentences = sent_tokenize(text)
    summary_sentences = [sent for sent in sentences if sent in selected_sentences]
    
    return ' '.join(summary_sentences)

# Example usage
sample_text = """
Artificial Intelligence is transforming the way we work and live. 
Machine learning algorithms can process vast amounts of data quickly. 
Deep learning models have achieved remarkable results in image recognition. 
Natural language processing enables computers to understand human language. 
AI applications are found in healthcare, finance, and transportation. 
The future of AI holds great promise for solving complex problems.
"""

summary = generate_summary(sample_text, num_sentences=2)
print("Original length:", len(sample_text.split()))
print("Summary length:", len(summary.split()))
print("Summary:", summary)

Original length: 53
Summary length: 26
Summary: Artificial Intelligence is transforming the way we work and live. AI applications are found in healthcare, finance, and transportation.

Backend Integration

The Django backend provides REST endpoints for processing meeting transcriptions ?

# Django views.py
from rest_framework.decorators import api_view
from rest_framework.response import Response
from .summarizer import generate_summary
from .translator import language_translate

@api_view(['POST'])
def process_transcription(request):
    text = request.data.get('text', '')
    source_lang = request.data.get('source_lang', 'english')
    target_lang = request.data.get('target_lang', 'english')
    
    # Generate summary
    summary = generate_summary(text)
    
    # Translate if needed
    if source_lang != target_lang:
        summary = language_translate(summary, source_lang, target_lang)
    
    return Response({
        'original_text': text,
        'summary': summary,
        'source_language': source_lang,
        'target_language': target_lang
    })

Key Features

• Realtime transcription ? Captures audio during live meetings

• Multilanguage support ? Translates summaries into 20+ languages

• Intelligent summarization ? Extracts key points using NLP algorithms

• User authentication ? Secure login with JWT tokens

• Data persistence ? Stores transcriptions in SQLite database

Conclusion

The Multilingual Google Meet Summarizer demonstrates effective integration of web technologies with machine learning for practical business applications. This project showcases how Python's NLP libraries can process meeting data and provide valuable insights across language barriers.