DEV Community: Abraham Dahunsi

PrivJob: ZK-Verified Job Board

Abraham Dahunsi — Mon, 08 Sep 2025 06:59:17 +0000

This is a submission for the Midnight Network "Privacy First" Challenge - Protect That Data prompt

What I Built

PrivJob is a revolutionary decentralized job board that leverages zero-knowledge proofs and blockchain technology to create a privacy-first hiring platform. In today's digital age, job seekers are increasingly concerned about their personal data privacy, while employers struggle to verify candidate qualifications without exposing sensitive information. PrivJob solves these challenges by enabling trustless verification of professional credentials while maintaining user privacy.

Demo:

privjob-demo.vercel.app

The platform allows job seekers to create verifiable professional profiles using attestations and zero-knowledge proofs, ensuring they only share necessary information with potential employers. Employers can post job listings with specific requirements, and the platform's smart matching system connects them with qualified candidates without exposing sensitive data. The entire process is secured by Midnight Network's privacy-preserving blockchain technology, ensuring that personal information remains confidential while still allowing for trustless verification of credentials.

Demo

privjob-demo.vercel.app

Abraham12611 / privjob

PrivJob

PrivJob is a privacy-first hiring platform that lets candidates prove what matters without exposing who they are. The product combines a modern Next.js frontend with a Fastify-based TypeScript backend and a secure PostgreSQL database (via Supabase) to deliver privacy-preserving job discovery, zero-knowledge credential verification, tamper-evident application tracking, and contact brokering that never leaks personal information by default. The implementation targets production reliability while centering Midnight-powered zero-knowledge workflows as first-class capabilities.

The system is intentionally split into two coherent layers. The frontend in src/ implements the candidate and employer experiences and hosts the zero-knowledge UX flows. The backend in backend/ exposes a clean REST API for jobs, applications, and contact requests; integrates with Supabase for Postgres and Row Level Security policies; and includes Redis for caching and privacy-preserving ephemeral data. A dedicated Midnight integration layer anchors verifiable credentials and privacy-preserving attestations to Midnight contracts while keeping sensitive material off-chain.

+---------------------+

…

View on GitHub

GitHub Repository

Key Screenshots:

Job Seeker Dashboard
- View and manage applications with privacy controls

Track application status with zero-knowledge verification

Manage professional credentials and attestations

Employer Portal
- Post job listings with privacy-preserving requirements

Review candidate applications with verified credentials

Initiate contact requests without exposing personal information

Verification Flow
- Visual representation of zero-knowledge proof verification

Credential management interface

Privacy settings and data sharing controls

How I Used Midnight's Technology

Midnight Network's technology stack was instrumental in building PrivJob's privacy-preserving features. The platform utilizes Midnight's Compact language to create smart contracts that handle job postings, applications, and credential verification without exposing sensitive data. The zk-SNARKs implementation allows for efficient verification of candidate qualifications while maintaining privacy.

The decentralized identity system built on Midnight enables users to create and manage their professional identities securely. Job seekers can selectively disclose information through zero-knowledge proofs, proving they meet job requirements without revealing the underlying data. This is particularly valuable for sensitive information like salary history or specific employment dates.

Midnight's confidential tokens are used for the platform's reputation system, allowing for verifiable feedback and ratings while protecting user identities. The blockchain's privacy features ensure that all interactions on the platform are confidential by default, with users having full control over what information they choose to share.

Data Protection as a Core Feature

Data protection is not just an afterthought in PrivJob – it's the foundation of the entire platform. Traditional job boards often require excessive personal information before any meaningful interaction can occur, creating significant privacy risks. PrivJob flips this model by implementing privacy by design at every level.

Professional credentials are stored as verifiable credentials on the Midnight blockchain, allowing candidates to prove their qualifications without revealing the underlying documentation. The platform uses zero-knowledge proofs to verify that candidates meet specific job requirements (e.g., "has 5+ years of experience" or "holds a relevant certification") without exposing the actual details of their experience or certification.

The contact request system is designed to protect both parties. Employers can only see a candidate's full profile after the candidate has approved a contact request, and all communications are encrypted end-to-end. Even the matching algorithm is privacy-preserving, using secure multi-party computation to match candidates with jobs without either party needing to reveal their full criteria.

Set Up Instructions / Tutorial

Prerequisites

Before getting started with PrivJob, ensure you have the following installed:

Node.js (v18 or later)
npm or yarn
Git
Midnight Network node (for local development)
PostgreSQL database
Redis server

Backend Setup

Clone the repository and install dependencies:

   git clone https://github.com/Abraham12611/privjob
   cd privjob/backend
   npm install

Set up environment variables by creating a .env file in the backend directory with the following variables:

   DATABASE_URL=postgresql://user:password@localhost:5432/privjob
   REDIS_URL=redis://localhost:6379
   JWT_SECRET=your_jwt_secret_here
   MIDNIGHT_NETWORK_URL=https://testnet.midnight.network

Run database migrations:

   npx prisma migrate dev

Start the development server:

   npm run dev

Frontend Setup

Navigate to the frontend directory and install dependencies:

   cd ../frontend
   npm install

Create a .env.local file with the following variables:

   NEXT_PUBLIC_API_URL=http://localhost:3000/api/v1
   NEXT_PUBLIC_MIDNIGHT_NETWORK_URL=https://testnet.midnight.network

Start the development server:

   npm run dev

Running the Application

Ensure your Midnight Network node is running locally
Start the backend server
Start the frontend development server
Access the application at http://localhost:3000

Creating Your First Job Posting

Sign up as an employer
Navigate to the dashboard and click "Post a Job"
Fill in the job details and requirements
Set privacy preferences for the application process
Publish the job listing

Applying for Jobs as a Candidate

Create a candidate profile
Add verifiable credentials to your profile
Browse available jobs and apply with one click
Approve contact requests from interested employers
Communicate securely through the platform's encrypted messaging

Verifying Credentials

Connect your digital wallet to the platform
Navigate to the "Credentials" section
Add verifiable credentials from supported issuers
Generate zero-knowledge proofs for specific job requirements
Share proofs with employers as needed

Conclusion

PrivJob represents a significant step forward in privacy-preserving recruitment technology. By leveraging Midnight Network's advanced cryptographic primitives, we've created a platform where both job seekers and employers can interact with confidence, knowing their sensitive information remains protected. The combination of zero-knowledge proofs, decentralized identity, and secure messaging creates a recruitment ecosystem that prioritizes user privacy without sacrificing functionality or trust.

As the digital landscape continues to evolve, platforms like PrivJob will become increasingly important in maintaining user privacy while enabling meaningful professional connections. The technology stack and architecture we've developed can serve as a blueprint for other applications that require privacy-preserving verification of credentials and information.

For developers interested in contributing to PrivJob or building similar privacy-focused applications, we encourage you to explore the codebase and join our community of privacy advocates and blockchain enthusiasts. Together, we can build a more private and secure digital future.

Xbeat : Supercharge E-cormmerce with Real-Time AI Powered by Redis 8

Abraham Dahunsi — Mon, 11 Aug 2025 06:00:17 +0000

This is a submission for the Redis AI Challenge: Real-Time AI Innovators.

What I Built

The Xbeat project is an e‑commerce conversational agent that treats Redis 8 as its real-time AI data plane. When a shopper for example asks a question like “Show me noise‑cancelling headphones under $1000,” the Xbeat AI agent does not blindly forward the text to an LLM. It first performs a semantic cache lookup in Redis to detect near‑duplicate questions; if one is found, the stored answer is streamed immediately to the UI and the response is labeled with an X-Cache: hit header. If no near‑duplicate exists, the system embeds the question, streams a fresh answer from the model, and writes that response back into Redis as a vector‑addressable entry. This turns repeated queries into instant responses, keeps answers grounded in data the app controls, and avoids unnecessary model calls.

Demo

Demo:

xbeat-main-nu.vercel.app

Video:

Repo:

Abraham12611 / xbeat-main

X-Beat | React eCommerce Web App

Demo Link 🔗

Audio Store eCommerce Website, built with React JS.
State management using Context API.

Features:

Add Product to the Cart
Remove Product from the Cart
Increment / Decrement the Product's Quantity
Product's Total Price / Discount Calculations
Filters - Sort by / Filter by Options
Custom Hooks
Local Storage
Fully Responsive
Dark Theme
Multi Pages
...and much more

Technologies used:

React JS
React Router
React Swiper
SASS

Author:

Gulshan Songara - Portfolio Website, Linkedin

Available Scripts:

`npm start`

`npm test`

`npm run build`

`npm run eject`

License:

This project is licensed under the GPL-3.0 License - see the LICENSE file for details.

View on GitHub

Screenshots:

Asks relevant questions for more context
Accurate and relevant response

Semantic Global Search

How I Used Redis 8

Redis is not a passive store in Xbeat. It actively decides whether to reuse or recompute every answer. The heart of the system is a RediSearch index that stores chat prompts, responses, and their embeddings. On each turn, the server computes an embedding for the last user message, executes a KNN(1) query over the vector field using cosine distance, and compares the nearest neighbor’s score to a tunable threshold. When the threshold is met, the cached response is streamed; when it is not, the model generates a fresh answer that is then persisted back into Redis with a TTL so the cache evolves in real time with the workload.

Redis Client and Connection Reuse

The Redis client is created once and cached at process scope, with TLS support for rediss:// URLs. This allows serverless handlers to reuse the connection efficiently. api/_lib/redisClient.js :

// api/_lib/redisClient.js
const { createClient } = require('redis');

let cachedClient = globalThis.__xbeatRedisClient || null;

function getRedisUrl() {
  return process.env.REDIS_URL || process.env.REDIS_URL_FALLBACK || '';
}

function getRedisPassword() {
  return process.env.REDIS_PASSWORD
}

function isRedisConfigured() {
  return Boolean(getRedisUrl());
}

async function getRedisClient() {
  if (!isRedisConfigured()) return null;
  if (cachedClient && cachedClient.isOpen) return cachedClient;

  const url = getRedisUrl();
  const password = getRedisPassword();
  const isTls = typeof url === 'string' && url.startsWith('rediss://');

  const client = createClient({ url, password, socket: isTls ? { tls: true } : undefined });
  client.on('error', (err) => console.error('[Redis] Client error:', err));

  try {
    await client.connect();
    globalThis.__xbeatRedisClient = client;
    cachedClient = client;
    return client;
  } catch (err) {
    console.error('[Redis] Failed to connect:', err);
    return null;
  }
}

module.exports = { isRedisConfigured, getRedisClient };

Semantic Cache: Vector Index and KNN Lookup

Xbeat stores chat history entries as HASHes and indexes them with RediSearch using an HNSW vector field in FLOAT32 format. The schema, lookup, and write‑back logic live in api/_lib/semanticCache.js :

// api/_lib/semanticCache.js
const { SchemaFieldTypes, VectorAlgorithms } = require('redis');

const INDEX_NAME = 'idx:chatcache';
const KEY_PREFIX = 'xbeat:chatcache:';
const VECTOR_DIM = parseInt(process.env.EMBEDDING_DIM || '1536', 10);
const DISTANCE_METRIC = 'COSINE';
const DEFAULT_TTL = parseInt(process.env.CACHE_TTL || '86400', 10);

async function ensureCacheIndex(client) {
  try {
    await client.ft.create(
      INDEX_NAME,
      {
        prompt: { type: SchemaFieldTypes.TEXT },
        response: { type: SchemaFieldTypes.TEXT },
        embedding: {
          type: SchemaFieldTypes.VECTOR,
          TYPE: 'FLOAT32',
          ALGORITHM: VectorAlgorithms.HNSW,
          DIM: VECTOR_DIM,
          DISTANCE_METRIC,
        },
      },
      { ON: 'HASH', PREFIX: KEY_PREFIX }
    );
    console.log(`[SemanticCache] Created index ${INDEX_NAME}`);
  } catch (e) {
    if (typeof e?.message === 'string' && e.message.includes('Index already exists')) {
      // OK
    } else {
      console.warn('[SemanticCache] ensureCacheIndex warning:', e);
    }
  }
}

async function findCacheHit(client, embeddingBuffer, threshold = 0.1) {
  const knnQuery = '*=>[KNN 1 @embedding $B AS score]';
  const options = {
    PARAMS: { B: embeddingBuffer },
    RETURN: ['score', 'response', 'prompt'],
    SORTBY: { BY: 'score', DIRECTION: 'ASC' },
    DIALECT: 2,
  };
  const results = await client.ft.search(INDEX_NAME, knnQuery, options);
  if (!results || !results.documents || results.documents.length === 0) return null;
  const doc = results.documents[0];
  const score = parseFloat(doc?.value?.score ?? '1');
  if (!Number.isFinite(score)) return null;
  if (score <= threshold) {
    return {
      key: doc.id,
      prompt: doc?.value?.prompt ?? '',
      response: doc?.value?.response ?? '',
      score,
    };
  }
  return null;
}

async function storeCacheEntry(client, { prompt, response, embeddingBuffer, ttl = DEFAULT_TTL }) {
  const key = KEY_PREFIX + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 8);
  await client.hSet(key, { prompt: String(prompt || ''), response: String(response || ''), embedding: embeddingBuffer });
  if (ttl && Number.isFinite(ttl)) await client.expire(key, Math.max(1, Math.floor(ttl)));
  return key;
}

module.exports = { ensureCacheIndex, findCacheHit, storeCacheEntry };

Chat Handler: Real‑Time Reuse or Recompute

The /api/chat route integrates the semantic cache into the request path. It parses the UI messages, embeds the last user message, checks Redis for a near‑duplicate, and either streams the cached response or streams a new model response and writes it back. The relevant logic is below api/chat.js:

// api/chat.js (excerpt)
const { getRedisClient, isRedisConfigured } = require('./_lib/redisClient.js');
const { ensureCacheIndex, findCacheHit, storeCacheEntry, extractLastUserText, extractTextFromUIMessage } = require('./_lib/semanticCache.js');

module.exports = async function (req, res) {
  // ...imports and parsing...
  const threshold = Number(process.env.SEMANTIC_DISTANCE_THRESHOLD || '0.1');
  const canUseCache = isRedisConfigured();
  let client = null;

  try {
    if (canUseCache) {
      client = await getRedisClient();
      if (client) {
        await ensureCacheIndex(client);
        const userText = extractLastUserText(uiMessages);
        if (userText && userText.trim().length > 0) {
          const embeddingBuffer = await embedTextToBuffer(userText);
          const hit = await findCacheHit(client, embeddingBuffer, threshold);
          if (hit && hit.response) {
            const stream = createUIMessageStream({ execute: ({ writer }) => { writer.write({ type: 'text', text: hit.response }); } });
            pipeUIMessageStreamToResponse({ response: res, stream, headers: { 'X-Cache': 'hit' } });
            return;
          }
        }
      }
    }
  } catch (cacheErr) {
    console.warn('[Chat API] Cache error (continuing without cache):', cacheErr);
  }

  const result = streamText({ model: openai(modelId), system: 'You are a helpful AI shopping assistant for X-Beat (audio gear store). Be concise, friendly, and product-focused.', messages: modelMessages });
  const uiStream = result.toUIMessageStream({
    onFinish: async ({ responseMessage }) => {
      try {
        const responseText = extractTextFromUIMessage(responseMessage);
        if (client && responseText && responseText.trim().length > 0) {
          const userText = extractLastUserText(uiMessages);
          const embeddingBuffer = await embedTextToBuffer(userText);
          await storeCacheEntry(client, { prompt: userText, response: responseText, embeddingBuffer });
        }
      } catch (e) { console.warn('[Chat API] onFinish error:', e); }
    },
  });
  pipeUIMessageStreamToResponse({ response: res, stream: uiStream, headers: { 'X-Cache': 'miss' } });
};

Search Handler: Vector Discovery Scaffold

The search route is included to show how KNN product discovery plugs into the same embedding pipeline. In this branch, api/search.js is scaffolded so the UI can be exercised while the product vector index module is isolated:

// api/search.js
'use strict';

module.exports = async (req, res) => {
  if (req.method !== 'GET') {
    res.status(405).send('Method Not Allowed');
    return;
  }

  const q = (req.query && (req.query.q || req.query.query)) || '';

  // TODO: implement RedisVL vector KNN search when Redis is configured.
  res.status(200).json({ query: q, results: [], pending: true });
};

Real‑Time Loop: Text → Embedding → KNN → Stream → Write‑back

Each chat turn follows the same loop: extract the last user message, embed it, query Redis for the nearest neighbor, stream a cached answer when the cosine distance is within the threshold, or stream a fresh model answer and write it back as a new HASH with a TTL. This turns every computation into a reusable asset and continuously lowers average latency and cost as traffic grows. Because thresholds, embedding dimension, and TTL are controlled by environment variables, deployments can tune strictness and freshness without code changes.

Running and Configuration

Use npm run dev:vercel to run both the React app and the serverless API locally via Vercel CLI. Set OPENAI_API_KEY for embeddings and chat, set REDIS_URL and REDIS_PASSWORD (or embed credentials in the URL) to connect to Redis 8 or Redis Stack, set SEMANTIC_DISTANCE_THRESHOLD to govern cache hit strictness (default 0.1), set CACHE_TTL to control entry lifecycle (default 86400), and set EMBEDDING_DIM to match the embedding model (default 1536). In production, deploy the same serverless handlers and provide the same environment variables.

Xbeat uses Redis to decide in real time whether to answer from memory or to compute a new response. The vector‑addressable semantic cache turns repeated or near‑repeated questions into instantaneous streams, while misses still benefit from structured write‑back that improves future latency. The result is an application where the data layer is the engine for retrieval, grounding, and reuse. Answers get smarter because they are grounded, and they get faster because every answer becomes a new shard of reusable, semantically searchable knowledge.

A Modern Intranet Template For Modern Startups

Abraham Dahunsi — Mon, 28 Jul 2025 06:58:12 +0000

This is a submission for Frontend Challenge: Office Edition sponsored by Axero, Holistic Webdev: Office Space

What I Built

I created Arxis, a modern, comprehensive intranet homepage designed as a central hub for internal communication, collaboration, and information sharing within organizations. My goal was to build a visually appealing, intuitive platform that boosts productivity, streamlines internal processes, and fosters a strong sense of community among employees.

The Arxis intranet homepage includes multiple interactive sections:

News Feed: Dynamic content with announcements, interactive engagement, and archival access.
Company Section: Overview of company values, structured department directories, leadership profiles, timelines, and collaborative insights.
Task Manager: Visual and interactive task management with dashboards, multiple views, drag-and-drop features, and comprehensive filtering.
Documents Section: Robust document repository supporting version control, previews, drag-and-drop uploads, and granular permission settings.
Teams & Community: Dedicated spaces for teams, interest groups, event calendars, and an employee skills directory.
Chat System: Real-time messaging with group chats, message automation, emojis, and read receipts.
Stories Section: Quick visual updates inspired by social media story formats, perfect for brief announcements.
Navigation System: Intuitive, state-managed navigation with clear indicators and breadcrumb trails.

Demo

You can explore the Arxis intranet homepage through the following link:

[Live Demo & Code Repository on GitHub]

Demo application: https://arxis.vercel.app/

Demo Video: https://youtu.be/S1gHjkaVg94?si=7qs97eY_kwHsPkJ0

Github: https://github.com/Abraham12611/arxis

Journey

Building Arxis was a multi-phase project, each stage meticulously planned to layer functionality progressively while ensuring a consistently smooth user experience.

Phase 1: Initial Design and Structure

I began by laying down a solid foundation—establishing responsive HTML and CSS structures, designing the intuitive navigation system, and setting the stage for future functionality. Getting this right early on significantly simplified later development phases.

Phase 2: Company Information Visualization

Implementing the company section required careful thought around data visualization and information hierarchy. Creating clear organizational structures, team directories, and interactive timelines posed interesting design challenges, pushing me to optimize the user interface for clarity and engagement.

Phase 3: Integrating Real-time Communication

The chat system was crucial for enhancing collaboration. I enjoyed designing the real-time messaging interface, complete with message automation, typing indicators, and expressive emoji support. It significantly improved internal communication dynamics.

Phase 4: Productivity with Task Management

Designing a visually intuitive task manager using dashboards, multiple views (Kanban and List), and robust filtering was particularly rewarding. Implementing drag-and-drop interactions significantly improved usability, streamlining task management workflows effectively.

Phase 5: Robust Document Management

The document section was challenging, particularly integrating version control, previews, and upload capabilities. Overcoming performance concerns with techniques like pagination, lazy loading, and optimized DOM manipulation was insightful and rewarding.

Phase 6: Community and Collaboration Tools

The final phase was all about community building—creating dedicated team spaces, community groups, and interactive event calendars. These features were vital in transforming Arxis into more than just an intranet, but a genuine community hub.

Technical Challenges and Solutions

Throughout development, several technical challenges arose:

State Management and Section Switching: Solved by implementing robust JavaScript-based state management and URL hash handling to preserve user context.
Responsive Design for Complex Components: Tackled through CSS Grid, Flexbox, and a mobile-first design approach, ensuring adaptability across devices.
Performance Optimization: Improved through lazy loading, debounced search functionality, and optimized DOM manipulations.
Cross-section Navigation: Enhanced with a context-preserving navigation system, ensuring seamless user experiences across sections.

Lessons Learned

This journey was highly educational, highlighting the importance of iterative design, modular architecture, and user-centric development. I’m particularly proud of creating a balance between sophisticated functionality and user-friendly design, ensuring Arxis is both powerful and intuitive.

Overall, Arxis evolved from a basic internal homepage into a comprehensive, interactive platform, capable of significantly enhancing organizational efficiency, collaboration, and community building.

Supercharge RealTime Multi-Language Translation with AssemblyAI

Abraham Dahunsi — Mon, 28 Jul 2025 05:38:12 +0000

This is a submission for the AssemblyAI Voice Agents Challenge

What I Built

I created LinguaBridge, a real-time bidirectional voice translation app. It utilizes AssemblyAI’s Universal-Streaming API for speech-to-text (STT), Google Gemini for instant translations, and Cartesia's high-performance text-to-speech (TTS) to deliver ultra-low-latency translations, targeting sub-300ms round-trip latency.

With LinguaBridge, conversations across language barriers become natural and effortless, ideal for real-time interactions in professional, personal, and educational contexts.

This submission addresses the Real-Time Performance Voice Agent prompt with:

Ultra-Low Latency: Sub-500ms round-trip voice translation latency.
Streaming Speech Recognition: Instantaneous processing of spoken input using AssemblyAI's Universal-Streaming API.
Immediate Translation: Real-time language translation via Google's Gemini Flash model.
Natural Voice Output: Instant text-to-speech synthesis powered by Cartesia TTS, ensuring natural conversational flow.
Multi-language Support: Seamless bidirectional translation across 12 languages, including English, Spanish, French, German, Chinese, and Arabic.

Core Problem Addressed

Effective communication across language barriers remains challenging in professional, educational, and personal contexts. LinguaBridge solves this by providing immediate, natural, and seamless voice translation, enabling effortless multilingual conversations in real-time.

Demo

Check out LinguaBridge live here:

duabridge.vercel.app

Abraham12611 / duabridge

LinguaBridge

Real-time cross-language voice translation with ultra-low latency.

Overview

LinguaBridge is a browser-based voice app that performs live bi-directional speech translation. Users select two languages (Speaker A and Speaker B). When a speaker talks, the app:

Transcribes speech with AssemblyAI's Universal-Streaming STT
Sends partial transcripts to Google Gemini 2.5 Flash for fast translation
Streams the translated output through Cartesia Sonic 2 or Sonic Turbo for ultra-fast TTS playback in the listener's language

All interactions are streamed with sub-300ms latency to enable fluid cross-language voice conversations.

Setup

1. Environment Variables

Create a .env.local file in the root directory with the following variables:

# AssemblyAI API Keys
# Get your API key from https://www.assemblyai.com/app/account
ASSEMBLYAI_API_KEY=your_assemblyai_key

# Google Gemini API Key
# Get your API key from https://aistudio.google.com/app/apikey
GEMINI_API_KEY=your_gemini_key

# Cartesia API Key
# Get your API key from https://cartesia.ai
CARTESIA_API_KEY=your_cartesia_key

2. Install Dependencies

npm install

Running the Application

LinguaBridge requires two processes…

View on GitHub

Demo Video

Screenshots

Landing Area

Language Selection

Voice Selection

Live Transcription Area

Technical Implementation & AssemblyAI Integration

1. Real-Time Speech Processing with AssemblyAI WebSocket API

LinguaBridge leverages AssemblyAI's WebSocket API for real-time speech-to-text transcription, ensuring ultra-low latency:

// lib/services/assemblyai-streaming.ts
export class AssemblyAIStreamingService {
  private ws: WebSocket | null = null;
  private currentLanguage = '';
  private onPartialCallback: ((text: string) => void) | null = null;

  async connect(
    language: string,
    onPartialTranscript: (text: string) => void,
  ): Promise<void> {
    this.onPartialCallback = onPartialTranscript;
    this.currentLanguage = language;

    this.disconnect(); // ensure clean connection
    await this.createWebSocketConnection(); // connect to AssemblyAI WebSocket proxy
  }
}

This implementation provides:

Real-time transcription with partial results.
Automatic reconnection handling.
Language-specific configurations.
Robust error handling.

2. Secure WebSocket Proxy for AssemblyAI Communication

To securely manage API keys and optimize performance, LinguaBridge implements a custom WebSocket proxy:

// server.js
const { WebSocketServer } = require('ws');
const WebSocket = require('ws');

// WebSocket server setup
wss.on('connection', (client) => {
  const upstream = new WebSocket(
    'wss://streaming.assemblyai.com/v3/ws?sample_rate=16000&format_turns=true',
    { headers: { authorization: ASSEMBLYAI_API_KEY } }
  );

  // Forward messages from AssemblyAI to client
  upstream.on('message', (data) => {
    if (client.readyState === WebSocket.OPEN) {
      client.send(data.toString());
    }
  });

  // Buffer audio data until ready
  client.on('message', (data) => {
    upstream.send(data);
  });
});

This proxy ensures:

Secure server-side API key management.
Audio buffering during connection setup.
Reliable and scalable communication.

3. Optimized Audio Capture with Web Audio API

LinguaBridge uses the Web Audio API and AudioWorklet for high-quality audio processing optimized for speech recognition:

// lib/services/audio-processor.ts
export class AudioProcessor {
  private audioContext: AudioContext | null = null;

  async startCapture(onAudioData: (data: ArrayBuffer) => void): Promise<void> {
    const audioContext = await this.initializeAudioContext();
    const stream = await navigator.mediaDevices.getUserMedia({
      audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true }
    });

    const source = audioContext.createMediaStreamSource(stream);
    await audioContext.audioWorklet.addModule('/audio-processor.js');

    const workletNode = new AudioWorkletNode(audioContext, 'audio-processor');
    workletNode.port.onmessage = (event) => {
      if (event.data.audioData) {
        onAudioData(event.data.audioData);
      }
    };
    source.connect(workletNode);
  }
}

This ensures:

Efficient audio capture at 16kHz mono.
Built-in noise suppression and echo cancellation.
Cross-browser compatibility.

4. Real-Time Translation via Google Gemini

LinguaBridge integrates Google's Gemini 2.5 Flash for ultra-fast translations:

// lib/services/gemini-translation.ts
export class GeminiTranslationService {
  private model: any = null;

  constructor(apiKey: string) {
    const genAI = new GoogleGenerativeAI(apiKey);
    this.model = genAI.getGenerativeModel({
      model: 'gemini-2.5-flash',
      generationConfig: { temperature: 0.1, maxOutputTokens: 1024 }
    });
  }

  async translateStream(text: string, sourceLang: string, targetLang: string): Promise<string> {
    // optimized translation logic
  }
}

This translation approach provides:

<150ms latency.
Intelligent caching and optimized prompts.
Robust error handling.

5. High-Speed Text-to-Speech with Cartesia

Cartesia TTS is integrated for fast, natural speech synthesis:

// lib/services/cartesia-tts.ts
export class CartesiaTTSService {
  private ws: WebSocket | null = null;

  async streamText(text: string, voiceId: string): Promise<void> {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      await this.connectWebSocket(voiceId);
    }

    this.ws.send(JSON.stringify({
      model_id: 'sonic-turbo',
      voice: { mode: 'id', id: voiceId },
      transcript: text,
      output_format: { encoding: 'pcm_s16le', sample_rate: 16000 }
    }));
  }
}

This implementation ensures:

Low-latency speech synthesis.
Seamless audio playback.
Multiple voice and language support.

6. End-to-End Real-Time Translation Pipeline

LinguaBridge orchestrates all services into a seamless, real-time pipeline:

// hooks/use-translation.ts
export const useTranslation = () => {
  const startTranslation = async (sourceLang, targetLang, voice) => {
    await audioProcessor.startCapture((audioData) => {
      assemblyAI.sendAudioData(audioData);
    });

    assemblyAI.connect(sourceLang, (transcript) => {
      gemini.translateStream(transcript, sourceLang, targetLang)
        .then((translation) => cartesia.streamText(translation, voice));
    });
  };
};

This coordination ensures:

Seamless real-time interaction.
Efficient resource management.
Dynamic error handling.

Integration Architecture

Complete LinguaBridge workflow:

Audio Capture → WebSocket Proxy → AssemblyAI STT → Gemini Translation → Cartesia TTS → Audio Playback

This architecture achieves:

Sub-500ms end-to-end latency.
High-performance scalability.
Robust and maintainable integration.

7. Multi-Language Real-Time Processing

LinguaBridge supports 12 languages with streamlined switching:

// app/page.tsx
const SUPPORTED_LANGUAGES = [
  { code: 'en', name: 'English' },
  { code: 'es', name: 'Spanish' },
  { code: 'fr', name: 'French' },
  { code: 'de', name: 'German' },
  { code: 'it', name: 'Italian' },
  { code: 'pt', name: 'Portuguese' },
  { code: 'ru', name: 'Russian' },
  { code: 'ja', name: 'Japanese' },
  { code: 'ko', name: 'Korean' },
  { code: 'zh', name: 'Chinese (Mandarin)' },
  { code: 'ar', name: 'Arabic' },
  { code: 'hi', name: 'Hindi' },
];

This ensures:

Bidirectional multilingual translation.
Dynamic language selection.
Integrated voice profile management.

DEV Community: Abraham Dahunsi

PrivJob: ZK-Verified Job Board

What I Built

Demo

Abraham12611 / privjob

PrivJob

Key Screenshots:

How I Used Midnight's Technology

Data Protection as a Core Feature

Set Up Instructions / Tutorial

Prerequisites

Backend Setup

Frontend Setup

Running the Application

Creating Your First Job Posting

Applying for Jobs as a Candidate

Verifying Credentials

Conclusion

Xbeat : Supercharge E-cormmerce with Real-Time AI Powered by Redis 8

What I Built

Demo

Abraham12611 / xbeat-main

X-Beat | React eCommerce Web App

Demo Link 🔗

Features:

Add Product to the Cart

Remove Product from the Cart

Increment / Decrement the Product's Quantity

Product's Total Price / Discount Calculations

Filters - Sort by / Filter by Options

Custom Hooks

Local Storage

Fully Responsive

Dark Theme

Multi Pages

...and much more

Technologies used:

React JS

React Router

React Swiper

SASS

Author:

Available Scripts:

npm start

npm test

npm run build

npm run eject

License:

How I Used Redis 8

Redis Client and Connection Reuse

Semantic Cache: Vector Index and KNN Lookup

Chat Handler: Real‑Time Reuse or Recompute

Search Handler: Vector Discovery Scaffold

Real‑Time Loop: Text → Embedding → KNN → Stream → Write‑back

Running and Configuration

A Modern Intranet Template For Modern Startups

What I Built

Demo

Journey

Phase 1: Initial Design and Structure

Phase 2: Company Information Visualization

Phase 3: Integrating Real-time Communication

Phase 4: Productivity with Task Management

Phase 5: Robust Document Management

Phase 6: Community and Collaboration Tools

Technical Challenges and Solutions

Lessons Learned

Supercharge RealTime Multi-Language Translation with AssemblyAI

What I Built

Core Problem Addressed

Demo

Abraham12611 / duabridge

LinguaBridge

Overview

Setup

1. Environment Variables

2. Install Dependencies

Running the Application

Demo Video

Screenshots

`npm start`

`npm test`

`npm run build`

`npm run eject`