Radio-G : Dynamic Multilingual News Desk

Radio-G: AI-powered summarized multilingual global audio news for all. We bridge media gaps for the visually impaired & non-English speakers with real-time, multilingual broadcasts.

Comment

'Radio-G': The AI-Powered Multilingual News Desk

Radio-G is a state-of-the-art news platform that leverages Generative AI to aggregate, translate, and broadcast global news in multiple languages. By utilizing an event-driven architecture with Confluent Kafka and Google Cloud, it provides a seamless, localized news experience for users regardless of their native tongue.

In the contemporary digital landscape, information is the currency of agency. The ability to access, interpret, and act upon real-time news streams dictates economic opportunity, political engagement, and social safety. However, the architecture of the global web remains stubbornly monolingual, or at best, oligolingual, with English, Mandarin, and Spanish dominating the transmission of high-velocity information. This creates a "linguistic digital divide" where vast populations are structurally excluded from the immediate consumption of global narratives.
Project 'radio-g', submitted for the AI Partner Catalyst Hackathon, represents a technical intervention into this asymmetry. By proposing an AI-powered multilingual news desk, the project aims to automate the complex pipeline of news ingestion, linguistic transposition, and semantic distribution. We have created a sophisticated microservices architecture leveraging Apache Kafka for event streaming, Redis for state management and de-duplication strategy, and Google Cloud’s AI suite for cognitive processing.

The societal impact of the project is how real-time, machine-translated news streams can serve marginalized communities specifically visually impaired users and non-dominant language speakers thereby addressing critical gaps in global media accessibility.

Features and Functionalities

Radio-G is designed to be an autonomous, intelligent news anchor that breaks down language barriers. It transforms static text news into a dynamic, multilingual audio broadcast.

  • AI-Powered News Curation & Summarization

    • The system ingests raw news data from various global sources.
    • It utilizes Google Gemini to intelligently summarize complex articles into concise, radio-style scripts suitable for broadcasting.

  • Real-Time Multilingual Broadcasting

    • Radio-G is not limited by geography. It automatically translates news content into multiple target languages while maintaining cultural nuance and context, powered by advanced LLMs.
    • Users can switch between languages instantly, receiving the same high-quality news stream in their native tongue.

  • Lifelike Audio Synthesis (The "Radio" Experience)

    • Going beyond text, the platform uses ElevenLabs to convert the summarized scripts into high-fidelity, natural-sounding speech.
    • This creates an immersive "listen-anywhere" experience, perfect for users on the go or those with visual impairments.

  • Event-Driven Real-Time Updates

    • Built on Confluent Kafka, the news desk operates in real-time. As soon as breaking news hits the source, it triggers an event pipeline that processes, translates, and broadcasts the update immediately—no page refreshes required.

  • High-Performance Caching

    • Integrated with Redis, the system caches frequently accessed news segments and audio files, ensuring ultra-low latency playback and a seamless user experience even under high traffic.

Technological Implementation

Radio-G is built on a scalable, event-driven microservices architecture that prioritizes decoupling, fault tolerance, and real-time processing.

  • Core Architecture: Event-Driven with Confluent Kafka

    • We moved beyond simple REST APIs by implementing an asynchronous Event-Driven Architecture (EDA) using Confluent Kafka.
    • Topic Design: We structured our Kafka topics to separate concerns: raw-news-feed for ingestion, and language-specific topics (e.g., news-hindi, news-bengali) for processed broadcasts.
    • Resilience: The system utilizes a "Fan-Out Consumer" pattern for the API layer, allowing multiple API instances to consume updates independently, ensuring data consistency without complex cache coordination.

  • Google Cloud Integration (Serverless & AI)

    • Cloud Run (Compute): The entire stack (API, Fetcher, Processor, Frontend) is containerized and deployed on Google Cloud Run. We utilize Cloud Run's auto-scaling capabilities (configured via deploy.sh with min/max instances) to handle traffic spikes efficiently.
    • Vertex AI / Gemini (Intelligence): We integrated Google Gemini 2.5 Flash via the GenAI SDK. We leverage Structured Output (Pydantic models) to force Gemini to return strict JSON for reliable downstream processing, ensuring the AI behaves deterministically.
    • Cloud Storage (Assets): Audio files generated by ElevenLabs are stored in GCS with automated Lifecycle Policies (configured to 1-day retention) to manage storage costs automatically.
    • Security: We use GCP Secret Manager to inject sensitive keys (Gemini, ElevenLabs, Kafka credentials) directly into the runtime environment, avoiding hardcoded secrets.

  • Partner Services Integration

    • Redis (Caching & State): We utilize Redis (integrated via Redis cloud for production) for two critical functions:
    • Deduplication: Using SHA256 hashes of article URLs to prevent processing the same news twice.
    • Dynamic Configuration: Storing active language profiles and voice mappings, allowing us to enable/disable languages in real-time without redeploying the code.

  • Engineering Excellence & DevOps

    • Unified Deployment Strategy: We created a robust deploy.sh script that unifies the deployment process. It handles prerequisite checks, secret creation, Docker builds (pushing to GCR), and service updates in a single command, ensuring repeatable and error-free deployments.
    • Abstraction Layers: The codebase features strict abstraction patterns (e.g., StorageService and TranslationProvider classes), allowing the system to switch between Local/Mock implementations and Production (GCP/Gemini) implementations seamlessly for easier testing and development.

Design

We prioritized a functional, accessible, and responsive design that allows users to access information quickly, regardless of their device or ability.

  • Mobile-First & Responsive:

    • Recognizing that many users access news on the go, the interface is built with a responsive grid layout that adapts seamlessly from desktop dashboards to mobile screens.

  • Accessibility & Readability:

    • We used a high-contrast dark theme (light text on dark slate backgrounds) to reduce eye strain and ensure readability in low-light environments.
    • The interface relies on standard semantic HTML elements and clear, universal icons (Play, Pause, Globe) to make navigation intuitive for all users, including those with lower digital literacy.

  • Intuitive "Radio" Controls:

    • The user flow is linear and simple: Select a Language → Pick a Story → Listen.
    • We implemented familiar audio controls (seek bars, volume, skip buttons) so users instantly know how to interact with the application without a learning curve.

Potential Impact

Radio-G addresses two critical global challenges: Language Barriers and Information Access.

  • Democratizing Global News:

    • By automatically translating major global news sources into local languages (like Hindi and Bengali), we empower non-English speakers to access the same real-time information as the rest of the world.

  • Aiding the Visually Impaired & Low Literacy Populations:

    • Traditional news sites rely heavily on text. Our "audio-first" approach makes news accessible to users who are visually impaired or have difficulty reading, providing them with a dignified way to stay informed.

  • Scalable Crisis Communication:

    • In times of emergency, rapid dissemination of information is vital. Our event-driven architecture allows for the immediate broadcasting of alerts in multiple languages simultaneously, potentially saving lives in diverse communities.

Quality of the Idea

  • Beyond "Static" Translation:

    • Most translation tools just convert text to text. Radio-G is unique because it transforms text into a broadcast. It creates a "lean-back" experience where users can listen to a curated stream of news just like a radio station, but powered by Generative AI.

  • The "Live" Factor:

    • Unlike podcasts which are pre-recorded and edited, Radio-G is dynamic. By using Confluent Kafka, the system reacts to news the moment it is published. This "Real-Time Event-Driven" approach is a significant leap forward from standard news aggregators that simply list links.

  • Production-Grade Architecture:

    • This is not just a concept wrapper. The project demonstrates a sophisticated integration of Partner Services (Confluent, Elevenlabs) with Google Cloud (Cloud Run, Vertex AI) to solve a complex problem—managing state, deduplication, and streaming audio at scale.

Findings & Learnings

  • The Power of Event-Driven Architecture (EDA)

    • Moving Beyond the Database: Coming from a traditional CRUD background, shifting to Confluent Kafka required a mindset change. We learned that "state" isn't just rows in a database; it's a fluid stream of events.
    • Decoupling for Speed: By implementing a Fan-Out Consumer Pattern, we discovered that we could make our API response times near-instant. Instead of querying a monolithic database for every user request, our API services consume the "news stream" independently and serve data from their own local cache. This allows the backend to handle spikes in traffic (like breaking news) without bogging down the ingestion pipeline.

  • Scaling AI: Balancing Innovation with Cost

    • The Rate Limit Wall: Integrating Gemini 2.5 and ElevenLabs taught us that AI APIs have strict physical and financial limits. We initially hit rate limits simply by testing with multiple RSS feeds.
    • Redis as the Gatekeeper: We implemented a strict Deduplication Layer using Redis. By hashing article URLs and checking them against Redis before requesting a translation, we reduced our AI API calls by over 40%. We learned that in an AI application, the most important code is often the code that decides when not to call the AI.

  • Cloud Synergy: The "Glue" Logic

    • Connecting Partner Services: We found that the real challenge wasn't writing code, but securely connecting distributed services. Using GCP Secret Manager became essential to bridge our Cloud Run services with Confluent Cloud (Kafka) and Redis Enterprise without exposing credentials.
    • Serverless Harmony: The combination of Cloud Run (stateless compute) and Confluent (stateful streaming) proved to be a powerful pattern. It allowed us to focus entirely on business logic (the "News Processor") while Google and Confluent managed the underlying infrastructure scaling.

Source and References

Project Repository

GitHub: https://github.com/tanjeetsarkar/radio-g – Contains full source code, architecture diagrams, and deployment scripts.

Built With

Share this project:

Updates