DEV Community: Jigin Vp

Empathy AI-Your AI Help.

Jigin Vp — Sun, 27 Jul 2025 23:02:11 +0000

This is a submission for the AssemblyAI Voice Agents Challenge

What I Built

EmpathyAI is a real-time voice-powered mental health support application that provides compassionate AI-driven conversations for individuals experiencing emotional distress. The system processes spoken input through advanced speech recognition, analyzes emotional content using AI, and responds with empathetic voice-based support.

Demo

GitHub Repository

React frontend app
https://github.com/vpjigin/EmpathyAIReact.git
Spring-boot backend
https://github.com/vpjigin/EmpathyAISpringBoot.git

AssemblyAI Universal-Streaming Technology

This application demonstrates advanced real-time audio processing powered by AssemblyAI’s Universal-Streaming API. The system enables low-latency, turn-based, and secure transcription, enabling emotionally intelligent AI conversations.

Core Architecture

The architecture follows a multi-layered streaming pipeline:
Client Audio → WebSocket Handler → AssemblyAI Streaming → AI Processing → Response

AssemblyAI Streaming Implementation

Real-time WebSocket Connection The backend creates a persistent WebSocket connection to AssemblyAI’s streaming endpoint:

private static final String ASSEMBLYAI_STREAMING_URL = "wss://streaming.assemblyai.com/v3/ws";

public CompletableFuture<StreamingSession> createStreamingSession(String sessionId, TranscriptCallback callback) {
    String connectionUrl = ASSEMBLYAI_STREAMING_URL + "?sample_rate=16000&format_turns=true";

    Map<String, String> headers = new HashMap<>();
    headers.put("Authorization", apiKey);

    WebSocketClient client = new WebSocketClient(serverUri, headers) {
        @Override
        public void onMessage(String message) {
            JsonNode jsonMessage = objectMapper.readTree(message);
            if ("Turn".equals(messageType)) {
                String transcript = jsonMessage.get("transcript").asText();
                boolean isFormatted = jsonMessage.get("turn_is_formatted").asBoolean();
                if (isFormatted) {
                    callback.onTranscript(transcript, true);
                }
            }
        }
    };
}

Audio Streaming Handler The AudioStreamingWebSocketHandler component bridges client-side audio to the AssemblyAI session:

@Component
public class AudioStreamingWebSocketHandler implements WebSocketHandler {

    @Autowired
    private AssemblyAIStreamingServiceV2 assemblyAIStreamingService;

    private void handleBinaryMessage(WebSocketSession session, BinaryMessage message) {
        StreamingSessionV2 assemblySession = assemblyAISessions.get(session.getId());
        if (assemblySession != null) {
            ByteBuffer audioData = message.getPayload();
            byte[] audioBytes = new byte[audioData.remaining()];
            audioData.get(audioBytes);
            assemblySession.sendAudioData(audioBytes);
        }
    }

    private void startStreaming(WebSocketSession session, String conversationUuid) {
        assemblyAIStreamingService.createStreamingSession(session.getId(), new TranscriptCallback() {
            @Override
            public void onTranscript(String text, boolean isFinal) {
                if (isFinal) {
                    handleFinalTranscript(session, conversation, text);
                }
            }
        });
    }
}

Advanced Features Utilized
Turn-based Transcription: format_turns=true for human-like flow
16kHz Audio: sample_rate=16000 ensures clarity
TLS/SSL Security: Secured with valid certs
Concurrent Streaming: Multiple session support
Message Type Handling: Supports "Begin", "Turn", and "Termination" types
Dual Implementation Strategy
I implemented two parallel streaming strategies:

AssemblyAIStreamingService: Uses Java-WebSocket for low-level WebSocket handling
AssemblyAIStreamingServiceV2: Uses Spring’s StandardWebSocketClient for seamless Spring Boot integration

// Spring-based implementation
public CompletableFuture<StreamingSessionV2> createStreamingSession(String sessionId, TranscriptCallback callback) {
    StandardWebSocketClient client = new StandardWebSocketClient();
    WebSocketHttpHeaders headers = new WebSocketHttpHeaders();
    headers.add("Authorization", apiKey);

    WebSocketHandler handler = new WebSocketHandler() {
        @Override
        public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) {
            // Handle messages using Spring WebSocket framework
        }
    };

    client.doHandshake(handler, headers, serverUri).get();
}

Technical Capabilities Leveraged

1.Real-time Binary Audio Streaming
2.Low-latency (<1s) Transcription
3.Turn-based Conversation Context
4.Error Recovery & Retry Mechanism
5.Scalable Concurrent Sessions

Project Structure (Brief)

├── controller/ ├── service/ ├── websocket/ ├── model/ ├── config/

When Replit Malfunctioned: Why We Must Build a Middle Layer Between AI and Core Infrastructure

Jigin Vp — Sun, 27 Jul 2025 17:19:24 +0000

The Replit Incident

Recently, developers across the world faced disruptions when Replit, one of the most widely used cloud-based IDEs, experienced a major malfunction. A company’s entire production database was wiped—was it entirely the AI’s fault? We all know AI is still in its early stages and can sometimes behave unpredictably, yet we continue to ignore the need for proper safety measures.
This blog is meant to shape a simple idea based on my thoughts.

Enter AI-Driven Applications

With AI now being a critical part of many applications—from smart chatbots to automated DevOps tools—developers often integrate models like GPT, Claude, or open-source LLMs directly into backend flows.

This architecture is powerful, but dangerously brittle.

Imagine this:
An AI agent receives a user’s query. It runs some logic and fires a direct SQL query to your production database. What if it misinterprets a prompt? Or calls the wrong endpoint? Or worse—starts deleting rows?

Combine this with a service malfunction like Replit’s, and you have a recipe for cascading failure.

Why a Middle Layer is Non-Negotiable

A middle layer—a controlled middleware or API abstraction—between AI agents and the actual backend systems (like your database or application server) is no longer just good practice. It’s essential.

Here’s why:

Validation & Rate Limiting

You can inspect and validate every request coming from the AI. Did it try to delete all users? Flag it. Is it flooding the server? Throttle it.

Explainability

The middle layer can log and surface what the AI is attempting to do in human-readable terms. This helps with debugging and auditing.

Security & Isolation

Your AI should never see raw credentials, database schemas, or internal APIs. The middle layer protects these via scoped endpoints or role-based access.

Fail-Safes

In the event of a malfunction—whether from the AI or the hosting platform (like Replit)—the middle layer can gracefully return fallback responses or queue retries.

AI Adaptability

Different AIs behave differently. A middle layer lets you abstract your backend so that whether you’re using GPT today and Claude tomorrow, your core logic doesn’t have to change.

Example Architecture

User → AI (LLM) → Middle Layer API → Backend Server / Database

The Middle Layer acts as a smart broker:
•Authenticates and logs every request.
•Filters unsafe or malformed inputs.
•Talks to the actual API/database through validated, pre-designed routes.

This way, even if:
•The AI hallucinates
•The user exploits prompt injection
•The platform malfunctions

…your infrastructure remains protected.

Final Thoughts

Replit’s malfunction reminded us of the fragile reality of modern cloud-based development. But the deeper takeaway for those building with AI is this:

Never let AI directly access your backend. Always add a human-governed, rules-based middle layer.

Think of it like giving a safety buffer between AI’s unpredictability and your infrastructure’s stability.

We’re still in the early days of AI-native architecture. Let’s build it responsibly.

Your Turn

Are you building AI apps? What does your middle layer look like—or are you still working without one?

Let’s discuss in the comments. 👇

Getting Started with Open WebUI: A Self-Hosted AI Interface

Jigin Vp — Tue, 17 Jun 2025 18:03:06 +0000

Open WebUI is an MIT-licensed project whose goal is to provide “the best AI user interface” for self-hosted large language models. At its core it’s a web app (Svelte + TypeScript + Python backend) that talks to:

Ollama (local LLM runner)
OpenAI-compatible APIs (e.g. LMStudio, Mistral, GroqCloud via custom endpoints)
Custom pipelines (RAG, tool-use via the pipelines framework)

The result? You get chat, voice/video calls, document uploads, memory/contexts, and even a built-in “model builder” to craft your own agents—all in one place.

Quickstart with Docker

The easiest way to stand up Open WebUI is with Docker. Here’s a GPU-enabled example:

docker run -d \
  -p 3000:8080 \
  --gpus=all \
  --add-host=host.docker.internal:host-gateway \
  -v ollama:/root/.ollama \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart=always \
  ghcr.io/open-webui/open-webui:ollama

If you don’t have a GPU, just omit the --gpus=all:

docker run -d \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v ollama:/root/.ollama \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart=always \
  ghcr.io/open-webui/open-webui:ollama

Once it’s running, point your browser at:
http://localhost:3000/auth

Key Features at a Glance

Effortless Setup: Docker, Docker Compose, Helm/Kustomize—pick your poison.
Multi-Runner Support: Ollama + any OpenAI-compatible URL.
Granular Permissions: Create user groups, roles, and fine-grained ACLs.
Responsive Design: Desktop, tablet, mobile—all handled.
Voice & Video Calls: Hands-free chat with built-in WebRTC support.
Model Builder: Create, customize, and deploy new Ollama models via the UI.
Plugin Framework: Extend with custom pipelines, filters, and memory modules.

First Steps After Installation

Connect Your Runner
Go to Settings → Model Runners and point to your Ollama socket (host.docker.internal:11434) or your OpenAI-compatible endpoint.
Create a Workspace
Workspaces let you isolate data, users, and models per project or team.
Chat & Explore
Hit New Chat, pick a model, and start experimenting with prompts, file uploads, or voice calls.

Customization & Extensions

Open WebUI’s power is in its extensibility:

Custom Pipelines: Write Python plugins to add status emitters, word filters, or long-term memory.
Theming: Override the default Svelte styles with your own CSS or brand colors.
Chrome Extension: Browse your workspace from any tab.
Desktop App: Use the Electron-based client for a native-feel experience.

Check out the docs for guides on each of these—there’s even a community-maintained list of “extensions you must try.”

Real-World Use Cases

Internal AI Assistant Host a Slack-integrated knowledge bot on your own servers—no third-party needed.
Research & Development Experiment with new LLMs in a controlled, offline environment.
Customer Support Ship a branded, self-hosted help-desk chatbot with RAG over your own docs.
Education Give students hands-on experience with AI without exposing them to external APIs.

Caveats & Tips

Resource Needs: Large models can be memory hungry. Make sure your host has enough RAM/VRAM.
Security: If exposing to the internet, sit behind an authenticated reverse-proxy (e.g., Nginx with OAuth).
Backups: Data lives in the open-webui volume—back it up regularly to avoid data loss.

Wrapping Up

Open WebUI puts the power and flexibility of modern LLMs right in your hands—completely self-hosted, fully open source. Whether you’re running internal assistants, experimenting with new models, or building your own AI-driven products, it’s a fantastic starting point.

Give it a spin, join the Discord community, and unlock the full potential of offline AI!
Happy hacking! 🚀

Getting Started with Open WebUI: A Self-Hosted AI Interface

Jigin Vp — Tue, 17 Jun 2025 18:03:06 +0000

Ollama (local LLM runner)
OpenAI-compatible APIs (e.g. LMStudio, Mistral, GroqCloud via custom endpoints)
Custom pipelines (RAG, tool-use via the pipelines framework)

The result? You get chat, voice/video calls, document uploads, memory/contexts, and even a built-in “model builder” to craft your own agents—all in one place.

Quickstart with Docker

The easiest way to stand up Open WebUI is with Docker. Here’s a GPU-enabled example:

docker run -d \
  -p 3000:8080 \
  --gpus=all \
  --add-host=host.docker.internal:host-gateway \
  -v ollama:/root/.ollama \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart=always \
  ghcr.io/open-webui/open-webui:ollama

If you don’t have a GPU, just omit the --gpus=all:

docker run -d \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v ollama:/root/.ollama \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart=always \
  ghcr.io/open-webui/open-webui:ollama

Once it’s running, point your browser at:
http://localhost:3000/auth

Key Features at a Glance

Effortless Setup: Docker, Docker Compose, Helm/Kustomize—pick your poison.
Multi-Runner Support: Ollama + any OpenAI-compatible URL.
Granular Permissions: Create user groups, roles, and fine-grained ACLs.
Responsive Design: Desktop, tablet, mobile—all handled.
Voice & Video Calls: Hands-free chat with built-in WebRTC support.
Model Builder: Create, customize, and deploy new Ollama models via the UI.
Plugin Framework: Extend with custom pipelines, filters, and memory modules.

First Steps After Installation

Customization & Extensions

Open WebUI’s power is in its extensibility:

Custom Pipelines: Write Python plugins to add status emitters, word filters, or long-term memory.
Theming: Override the default Svelte styles with your own CSS or brand colors.
Chrome Extension: Browse your workspace from any tab.
Desktop App: Use the Electron-based client for a native-feel experience.

Check out the docs for guides on each of these—there’s even a community-maintained list of “extensions you must try.”

Real-World Use Cases

Internal AI Assistant Host a Slack-integrated knowledge bot on your own servers—no third-party needed.
Research & Development Experiment with new LLMs in a controlled, offline environment.
Customer Support Ship a branded, self-hosted help-desk chatbot with RAG over your own docs.
Education Give students hands-on experience with AI without exposing them to external APIs.

Caveats & Tips

Resource Needs: Large models can be memory hungry. Make sure your host has enough RAM/VRAM.
Security: If exposing to the internet, sit behind an authenticated reverse-proxy (e.g., Nginx with OAuth).
Backups: Data lives in the open-webui volume—back it up regularly to avoid data loss.

Wrapping Up

Give it a spin, join the Discord community, and unlock the full potential of offline AI!
Happy hacking! 🚀

Gemini AI – A Complete AI Tutor That Watches Your Screen and Guides You in Real Time!

Jigin Vp — Sat, 19 Apr 2025 19:59:18 +0000

Hey folks 👋

If you thought AI assistants were just for chatting or summarizing emails, Google’s Gemini AI is here to surprise you — in the best way possible. It’s not just smart. It’s not just fast. It’s a complete AI assistant — and yes, it can even record and understand your screen.

Let’s dive into what makes Gemini one of the most futuristic and helpful tools in the AI space right now.

Screen-Aware Assistance – Yes, Really

One of Gemini’s most powerful and mind-blowing features is its ability to observe and understand what’s happening on your screen (with permission, of course).

That means Gemini can:

Guide you step-by-step while you’re using apps
Identify problems as they occur on-screen
Help you fill forms or troubleshoot workflows
Suggest actions based on what you’re doing in real-time

Imagine trying to configure a new tool or write a formula in Google Sheets — and Gemini just nudges you with exactly what you need.

It’s like screen sharing with an AI that actually helps, instead of just watching.

Not Just a Chatbot – A Full AI Assistant

Gemini is more than just a text box. It's deeply integrated with Google’s ecosystem, which means it can:

Write code, answer complex queries

Help plan your day, generate summaries

Fetch data, organize tasks

Connect with Google Workspace apps

And with Gemini 1.5, it's faster, smarter, and even more context-aware.

Use Cases That Blow the Mind

Here’s what you can actually do with Gemini AI:

Ask it to generate a response to a long email while it sees the thread
Open a form and let it guide you through filling it out
Work on a document while Gemini offers editing tips live
Use it during development for code suggestions that match what you’re actively working on

The possibilities keep growing as more integrations roll out.

How to Get Started with Gemini AI

Getting started with Gemini AI is super easy and free for most users:

Go to Google ai studio
Sign in with your Google account
You’ll be taken to AI Studio, where you can start chatting
Click on "Stream real time"
From there, you can enable video conversation or screen sharing

If you share your screen, Gemini can now see what’s on it and help you in real-time — just like having a tutor sitting next to you.

Advanced features like Gemini 1.5 Pro are available through Gemini Advanced, but the core experience is already incredibly powerful for free.

That’s it! Start typing, exploring, and let Gemini become your AI teammate.

Privacy and Control

Screen assistance requires permission, and Google has built in strong privacy protections. You stay in control — it only observes what you allow it to.

And to make this even clearer: I personally asked Gemini some tough privacy questions:

"Are you recording my screen?"
"Are you saving this screen recording somewhere so you can train your AI?"
"Do I need to hide any specific data so that you will not misuse it?"

Gemini’s answer was simple and consistent:

"The screen recordings are done only to observe the content in order to give you a proper and useful reply. When this session is ended, no data is sent or saved anywhere."

So yes — you’re in control, and your data stays private.

AI assistants are no longer just for chat — they’re becoming co-pilots in real-time work environments. With Gemini AI’s screen-aware capabilities and Google-native integration, the future of intelligent assistance is already here.

If you haven’t tried it yet — it might just change how you work, learn, and build.

Extra: A Great Video Walkthrough

Youtube
If you’re more of a visual learner or want to see Gemini AI in action, I highly recommend checking out this YouTube video:

▶️ Gemini AI Demo – Real-Time Assistance & Screen SharingIt gives a hands-on view of how powerful Gemini’s screen-aware features are and how it works like a real-time tutor.

Signing off,
Jigin – Always watching new tools that watch and help you back.

Claude AI – The Superhero All-Rounder for Your Entire Tech Team

Jigin Vp — Fri, 04 Apr 2025 05:18:15 +0000

Hey devs 👋

Many of us have heard about Claude AI – Anthropic’s smart, safe, instruction-following AI assistant. But did you know it’s not just a chatbot anymore?

That’s right. Claude AI now comes with a developer tool called Claude Code, and it’s a complete game-changer.

Let me introduce you to the Copilot-style Claude AI you didn’t know you needed.

Claude AI – More Than Just a Chatbot

Claude AI has evolved from just answering your questions on a web interface. With its new Claude Code package that you can install it on your machine, connect it to your project, and let it assist you like a true coding sidekick.

Once connected to your project, Claude can:

Scan your entire codebase

Understand your framework, architecture, and structure

Answer context-aware questions based on your project

What Can Claude Code Do?

Let’s say you’re developing a Spring Boot application — here’s how Claude shines:

Detects security vulnerabilities in your project
Optimizes long and complex functions
Suggests query optimizations for APIs
Recommends improvements for code quality

But that’s not all — you can even ask Claude questions like:
"How many developers worked on this project?"
"Which developer made the most commits?"
"Based on commits, rate a developer out of 10."

Claude will run Git commands under the hood and give you these insights directly from the terminal UI. 🤯

System Requirements & Setup Guide

OS: macOS 10.15+, Ubuntu 20.04+/Debian 10+, or Windows via WSL

RAM: Minimum 4GB

Software Dependencies:

Node.js 18+

git 2.23+ (optional)

GitHub/GitLab CLI (for PR workflows - optional)

ripgrep (rg) for better file search (optional)

Internet: Required for authentication and AI processing

Region: Only available in supported countries → List here

How to Set It Up

Install Node.js 18+, then run:

npm install -g @anthropic-ai/claude-code

Navigate to Your Project

cd your-project-directory

Launch Claude Code

claude

Authenticate Follow the OAuth flow using your Anthropic Console account

Active billing is required

That’s it. Once authenticated, Claude is ready to assist you — directly inside your local project.

Claude Code is one of the most exciting developments in AI-assisted coding. It’s smart, it’s fast, and it doesn’t just suggest code — it understands your code.

Whether you’re building something solo or managing a large project, Claude can:

Save you time

Boost your code quality

Make project insights fun and effortless

Give it a spin — it might just become your new favorite dev tool.

Signing off,Jigin – Always exploring the next superhero in my dev toolkit.

From Burnout to Balance – What I’m Changing as a Developer

Jigin Vp — Thu, 03 Apr 2025 05:21:09 +0000

Hey again, devs 👋

After sharing a couple of posts, I felt like it was time to talk about something different — about taking a step back from coding in order to move forward. A lot of us go through the same cycle: burning out, feeling stuck, coding non-stop, and forgetting to just live.

Today, I want to talk about something a bit deeper: balance.

## The Grind is Real
Let’s be honest — being a developer can easily take over your whole life.
Deadlines. Bugs. Feature requests. Refactors. Debugging bugs that only happen when Mercury is in retrograde. 😅

And sometimes, the love we have for what we do makes it even harder to step back.

What I’m Changing

This isn’t just a post to vent — I want to be intentional with the way I grow. So here’s what I’m actually starting to do:

No more working past midnight (unless I’m in flow and loving it — not just grinding).
1 hour daily for non-tech stuff — walks, reading, music, just something not involving code.
Weekend = personal time, not “catch up on all side projects and burnout again” time.
Talk to people more — devs, friends, even strangers. Real conversations. Not just Stack Overflow threads.

What You Can Ask Yourself

If you’re in the same boat, try asking:

When was the last time I logged off and felt fully done for the day?
What’s one hobby I’ve been ignoring?
Am I coding because I want to — or because I feel I have to?

TL;DR

I’m not quitting dev life. I love it too much.
But I’m done letting it be the only thing I do.

So if you’ve been feeling stuck, burned out, or just… robotic, maybe take a step back and ask yourself:
“What does balance look like for me?”

Let’s all try to find our version of that — together.

Signing off again,

Jigin – Human first, developer second (trying, at least 😄)

Kotlin multiplatform - What it differ from other cross platforms

Jigin Vp — Wed, 02 Apr 2025 07:26:56 +0000

Hey everyone,

We are known of so many cross-platform frameworks in recent years that includes flutter, react-native, ionic, xamirin and goes on. All are promissing one thing, build once run anywhere.
Today we can get a look at the new player in the same segment - Kotlin Multiplatform and how it differ from others.

Shared logic and not UI

Kotlin Multiplatform(KMM) shared the business logic. The api calls, catching, algorithms or anything which is common to iOS and Andorid will be written in shared logic.
These shared logic is public for iOS and Android platform.

UI developement is seperate for iOS and Android, ie. iOS UI will be developed using swift UI and Android will be developed in Jcompose. Which gives us platform dependent UI experience for both the users which is a great plus.

Keep the native codebase

Unlike frameworks that abstract everything away (like Flutter’s rendering engine or RN’s JavaScript bridge), KMP works with your existing native projects.

You can gradually migrate or share code without rewriting everything. This makes KMP a great fit for teams maintaining mature Android and iOS apps who want to reduce code duplication without a full rewrite.

Written in Kotlin, a known language for Android

If you’re already an Android developer using Kotlin, you’ll love KMP. No learning Dart, JavaScript, or C#.

Also,

The shared modules are pure Kotlin.
You can use Kotli
n libraries (like Ktor, Coroutines, Serialization) across platforms.

KMM is not for mobile alone

KMP is truly multiplatform:

Android (JVM)
iOS (Native)
Backend (JVM)
Web (via Kotlin/JS)
Desktop (Compose Multiplatform)
Even WebAssembly (experimental)

So if you’re building shared SDKs, libraries, or full-stack apps, Kotlin Multiplatform offers some powerful potential.

But It’s Not All Roses

Like any tech, KMP has its challenges:

iOS setup can be tricky at first (especially with cocoapods + Xcode integration).
Smaller ecosystem compared to Flutter or React Native.
UI has to be written separately — more work if you’re aiming for a quick prototype.

But for apps where performance, maintainability, and code reuse matter, KMP really shines.

So… Who Should Use It?

✅ Use KMP if:

You already use Kotlin and want to reuse business logic across platforms.
You want to avoid bloated frameworks or rendering engines.
You prefer native UI and platform-specific behavior.
You’re building SDKs or libraries that need to work everywhere.

❌ Avoid it if:

You want one codebase for everything, including UI.
Your team has zero Kotlin experience.
You need very rapid UI prototyping across platforms.

Kotlin Multiplatform isn’t trying to be a Flutter or React Native replacement. It’s giving developers more control, better integration, and smarter code sharing.

For teams that want to maintain platform-specific UI while still avoiding code duplication in logic, KMP is a powerful and flexible alternative.

Signing off,
Jigin – Exploring cross-platform, one shared module at a time.

Meet Gemma: Google’s Lightweight Open-Source AI Model for Devs

Jigin Vp — Wed, 02 Apr 2025 06:01:33 +0000

Hey devs 👋

There’s a lot happening in the AI space, and one name that recently caught my attention is Gemma — Google’s open-source family of lightweight, state-of-the-art generative AI models.
As someone who’s been experimenting with AI tools lately (mostly ChatGPT, some Hugging Face models), I wanted to try out what Google brought to the table — and I wasn’t disappointed.

So here’s a quick breakdown of what Gemma is, why it matters, how it compares to other models like Gemini, and how developers like us can get started.

A Quick Recap of Gemma's Success:

Before diving into Gemma let us take a look back and find what's the pressessor was capable of,

Open Source & Accessible: This was a key point. Making the model weights freely available to researchers, developers, and hobbyists to experiment, adapt, and contribute to the Gemma ecosystem.
Competitive Performance: Gemma had a strong performance across various benchmarks, often rivaling larger models in market and closed-source models in specific tasks.
Variety of Sizes: Gemma came in different sizes (e.g., 2B, 7B) allowing users to choose the right balance between performance and computational cost.
Pre-trained and Instruction-tuned Versions: Google provided both pre-trained models and instruction-tuned versions, catering to different use cases. The instruction-tuned models, often named with it were ready for conversational applications right out of the box.
Responsible AI Focus: Google emphasized responsible AI development, incorporating safeguards and transparency around the model's capabilities and limitations.

Gemma Variants:

There are two main sizes of the Gemma model family:

Gemma 2B - This has 2 billion parameters. It's available in both pretrained and instruction-tuned formats. Ideal for lightweight use cases and local development.

Gemma 7B - With 7 billion parameters, this version offers more power while still being fairly lightweight.

Both versions also come in instruction-tuned variants:

Gemma 2B-it - Fine-tuned for tasks like chatbots and QA.

Gemma 7B-it - Fine-tuned for more complex reasoning tasks.

You can access Gemma models via Hugging Face, Kaggle, Google Cloud Vertex AI, or Colab.

Gemini or Gemma

A very and short comparison:

Gemma is open-source and optimized for local or lightweight applications. Great for developers, hobbyists, and researchers.

Gemini is Google's proprietary model suite (formerly Bard). It's more powerful, designed for enterprise-grade performance, and includes tools like Gemini Advanced, Gemini Nano (for Android), and Gemini Ultra.

In short:

If you want full control and custom experiments: Use Gemma.

If you want enterprise-level performance with built-in tools: Use Gemini.

How to use?

You can run Gemma on:

Your local machine (with good enough RAM/GPU)

Google Colab (free-tier is enough to get started)

Hugging Face Spaces or directly via transformers

A simple example from python

from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("google/gemma-2b")
model = AutoModelForCausalLM.from_pretrained("google/gemma-2b")

While ChatGPT and Gemini 1.5 are powerful and ready to use, open source models like Gemma are where dev creativity thrives. You can tune it, host it, embed it, and even build something weird (but awesome).

If you're a developer curious about building with AI without relying fully on APIs, give Gemma a shot.

Signing off,Jigin – Always exploring, whether it’s code, coffee, or open AI models.

Getting Started with Generative AI – A Developer’s Perspective

Jigin Vp — Sun, 30 Mar 2025 14:00:43 +0000

Hey devs 👋

If you’ve been anywhere near the tech world recently, you’ve probably heard the buzzword: Generative AI. From creating images, code, music, to even creating a whole video for you, generative AI is making some serious noise here now.

So I thought… why not write a post about it? Not as an expert, but as a developer who’s just beginning to explore this fascinating space — and maybe help others take their first step too.

What is Generative AI, really?

Generative AI is a branch of AI that focuses on creating unique contents. Unlike traditional AI that’s trained to classify or predict (e.g., “is this image a cat or a dog?”), generative AI is trained to produce entirely new content — like generating an image of a cat that doesn’t even exist yet or to create a story of a bird and elephant that no one even heard of.

Some cool tools you can start with can be,
ChatGPT – for generating natural language responses
DALL·E / Midjourney – for AI-generated images
GitHub Copilot – for code suggestions
MusicLM / Suno AI – for AI-generated music

How Does It Work?

Without going too deep into the math(seriously i also doubt i know much): most of these models are based on deep learning techniques — specifically, models like transformers, diffusion models, and GANs (Generative Adversarial Networks).

They’re trained on massive datasets (text, code, images) and learn to mimic the patterns, styles, and logic to generate something new and (hopefully) useful.

Why Should Developers Care?

In this AI era, developers should leverage the power of AI in their daily lifes, because it’s not just for fun. Developers can:

Build apps faster with AI-powered code assistance
Prototype faster with AI-generated assets (text, images, etc.)
Add value to apps with AI-powered features (e.g., chatbots, smart content)
Create tools using open models like OpenAI, Hugging Face, or Google’s Gemma

Want to Try It Out?

If you’re curious:

https://platform.openai.com – Try the APIs directly
https://huggingface.co – Explore tons of open models
https://replicate.com – Run AI models in your own apps with zero setup

Final Thoughts

Generative AI isn’t just hype — it’s a toolbox. The more you learn to use it, the more possibilities open up. You don’t need to be an ML expert to get started — just curiosity and a few lines of code.

If you’re already experimenting with it, I’d love to hear what you’re building! And if not — maybe this is your sign to start.

Signing off,
Jigin – Just a dev trying to train my brain while the AIs train themselves.

Unlocking Biometric Authentication in Android – A Developer’s Guide (with Tips)

Jigin Vp — Sat, 29 Mar 2025 11:09:29 +0000

Hey devs 👋

I’m Jigin, and I’ve been building Android apps for a while now — from traditional login flows to full-blown business management tools. Lately, I’ve been diving into biometric authentication, and I thought I’d share a quick guide, some tips, and a few hard-learned lessons that might help fellow devs out there.

Whether you’re looking to tighten security or give your users that sweet “just tap and go” experience, this one’s for you.

🔐 Why Biometric Authentication?

Security: Passwords can be forgotten. Biometrics are you.
Convenience: One tap > typing passwords.
Trust: Modern apps with native biometric support feel polished and reliable.

What I Used

Language: Kotlin
Tools: BiometricPrompt API
Min SDK: 23 (but actual support starts from Android 6.0+)

Basic Implementation Steps

val executor = ContextCompat.getMainExecutor(this)
val biometricPrompt = BiometricPrompt(this, executor,
    object : BiometricPrompt.AuthenticationCallback() {
        override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
            super.onAuthenticationSucceeded(result)
            // Navigate or unlock secured features
        }

        override fun onAuthenticationFailed() {
            super.onAuthenticationFailed()
            // Handle failure
        }
    })

val promptInfo = BiometricPrompt.PromptInfo.Builder()
    .setTitle("Biometric Login")
    .setSubtitle("Log in using your fingerprint")
    .setNegativeButtonText("Cancel")
    .build()

biometricPrompt.authenticate(promptInfo)

⚠️ Gotchas I Faced

Emulator doesn’t help – Test on real devices!
Fallback login – Always have PIN/password fallback for devices without biometrics.
Handle all cases – Locked biometrics, no enrolled fingerprint, hardware not available, etc.

💡 Pro Tips

Use BiometricManager to check device capabilities before launching the prompt.
Use encrypted SharedPreferences if you’re storing auth flags.
Keep UX smooth — if biometric fails, don’t force the user through a maze.

Real-World Use Case

I recently integrated this in an internal business management app, where biometric unlock helped speed up logins for admins accessing sensitive financial data. It improved both user satisfaction and compliance.

🗣️ Final Thoughts

Biometric auth isn’t just “cool tech” anymore — it’s becoming a user expectation. With just a few lines of code and good fallback handling, you can add it to your Android app and instantly make it feel more modern and secure.

Let me know if you’d like a version of this for Kotlin Multiplatform or paired with a Spring Boot backend — that’s something I’ve been playing with too. 😄

Signing off,
Jigin – Trying to keep things secure and smooth, one tap at a time.

A Hard Refresh - Taking a Break (Sort of) – My First Step Toward Change

Jigin Vp — Fri, 28 Mar 2025 18:07:09 +0000

Hey there! 👋

This is my very first blog post on dev.to, and honestly, it feels both exciting and a little nerve-wracking to put my thoughts out here. But that’s exactly why I’m doing this — to step out of my comfort zone and start something different.

A Quick Intro 👨‍💻

I’m Jigin, a developer who’s been deep in the code trenches for the past couple of years — mostly Android and backend stuff. I love solving problems, debugging tricky issues, and getting that sweet satisfaction of “Yes! It finally works!” (We’ve all been there, right? 😅)

But somewhere along the way, I realized something:

I’ve been living with technology, but not really living outside of it.

The Routine

Wake up → laptop → code → eat → code → sleep → repeat.
That’s been my loop for a long time. I wasn’t exploring, meeting new people, or growing outside of code. It hit me that I was becoming more of a machine than the ones I work with.

Why I’m Here

So here I am — on dev.to — hoping to connect with like-minded developers, share what I know, learn from all of you, and just… grow. Not just as a dev, but as a person too.

This post is me saying “I’m hitting refresh.”
Not on my browser. On myself.

What’s Next?

I’ll be sharing things I learn, stuff I break (and fix), random dev thoughts, and maybe even some personal growth updates. If any of that sounds interesting, feel free to follow along. Or drop a comment — I’d love to say hi!

Thanks for reading, and here’s to new beginnings! 🚀

Signing off --- Jigin