Coder Legion - Recent posts tagged gemmachallenge

Solace: A Global Mental Health First Responder Built with Gemma 4

Wed, 03 Jun 2026 19:37:18 +0000

The Problem Nobody Talks About

970 million people worldwide live with mental health disorders.

But almost every mental health tool built with AI assumes the same user: fast internet, English as a first language, a US or UK phone number to call in a crisis.

That's not 970 million people. That's maybe 50 million.

I'm a developer based in Lagos, Nigeria. When I looked at the mental health AI tools being built, I kept asking the same question: what happens when someone in Accra, Nairobi, Manila, or São Paulo needs help at 2am?

They get a chatbot that tells them to call 988.

That's the gap Solace was built to close.

What is Solace?

Solace is a voice-first, privacy-focused mental health companion powered by Gemma 4. It listens, assesses, and connects people to real help — wherever they are in the world.

Live app: https://slcai-sm9m.vercel.app/
GitHub: https://github.com/sam-the-champ/SLCAI

Demo Video:

What makes Solace different

1. Localized crisis resources for 13+ countries

Most mental health AI tools are built with US resources baked in. If you're not American, you're on your own.

Solace auto-detects your country from your browser timezone and immediately surfaces the right crisis lines, text lines, and chat services for Nigeria, Ghana, Kenya, South Africa, Zimbabwe, India, UK, USA, Canada, Australia, Philippines, Singapore, Brazil — and falls back to international resources for everywhere else.

No settings. No configuration. It just knows.

export function getResourcesByTimezone(): CountryResources {
  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone
  const tzToCountry: Record<string, string> = {
    'Africa/Lagos': 'NG',
    'Africa/Accra': 'GH',
    'Africa/Nairobi': 'KE',
    // ...13+ countries
  }
  const code = tzToCountry[tz]
  return resourcesByCountry[code] ?? resourcesByCountry.DEFAULT
}

2. Voice-first input

When someone is in distress, typing is a barrier. Solace has a one-tap voice input powered by the Web Speech API — speak your feelings, Solace listens.

No third-party API. No extra cost. Works in the browser natively.

const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition
recognition.continuous = true
recognition.interimResults = true

3. Trauma-informed triage with Gemma 4

Every message is assessed across four triage levels: Low → Moderate → High → Crisis.

Gemma 4's 128K context window and deep instruction-following made it the right model for this. The system prompt is carefully crafted to avoid clinical coldness while still being precise enough to catch crisis signals:

// Triage levels:
// low: mild everyday stress, general worry
// moderate: persistent sadness, sleep issues, social withdrawal  
// high: panic attacks, trauma symptoms, major crisis
// crisis: suicidal ideation, self-harm, immediate danger

At crisis level, the entire UI shifts — emergency resources move to the top, the call button becomes prominent, and the AI's tone changes to prioritize connection to real help over conversation.

4. Private mood journal

Every check-in is saved to a local mood journal — stored entirely in localStorage. No server. No account. No data leaving the device.

Users can track patterns across sessions: when they tend to feel worse, whether things are improving, what their check-ins look like over time.

5. Installable PWA

Solace is a Progressive Web App. On mobile, users can install it directly to their home screen — no app store, no download, works in low-bandwidth conditions.

This matters enormously in markets like Nigeria where data costs are high and storage is limited. A 2MB installable app beats a 200MB download every time.

Why Gemma 4 specifically?

This is the question that matters most, so let me be direct.

I chose Gemma 4 31B because:

1. The 128K context window means Solace can hold a full therapeutic conversation — not just one or two turns. Mental health support isn't transactional. People circle back. They contradict themselves. They need to feel heard across a long exchange.

2. Instruction-following precision — the triage system depends on Gemma 4 returning structured JSON reliably, with emotional nuance baked into the summary, patterns, strategies, and affirmation fields. I tested with smaller models. The quality gap was significant.

3. It's open. Gemma 4 can be self-hosted. That means a clinic in Lagos or a NGO in Nairobi could eventually run this on their own infrastructure, with no API costs and full data sovereignty. That's a future worth building toward.

4. Privacy story. Every conversation stays between the user and the model. Solace doesn't log, store, or transmit conversation data. For mental health, that's not a feature — it's a requirement.

Technical Stack

Frontend: React + Vite + TypeScript
Styling: CSS custom properties, glassmorphism UI, no component library
AI: Gemma 4 31B via OpenRouter
Voice: Web Speech API (native browser)
Storage: localStorage (journal, no server)
PWA: Web App Manifest + service worker ready
Deploy: Vercel

The hardest part

Building the crisis response flow was the hardest and most important part of this project.

When Gemma 4 returns triageLevel: "crisis", everything changes. The UI shifts to red. The emergency number for the user's country moves above the fold. The AI's system prompt switches to a mode focused entirely on staying present and bridging to real help — not providing therapy.

Getting that balance right — compassionate but not clinical, urgent but not alarming — took more iteration than anything else in the codebase.

What's next

Offline-first fallback responses — cached grounding techniques that work with no internet
More languages — French, Hausa, Swahili, Portuguese
More countries — currently 13, targeting 30+
NGO partnership mode — white-label for mental health organizations

Try it

https://slcai-sm9m.vercel.app/

Open it on your phone. Tap a mood. Speak how you're feeling. See what country resources appear for you.

If you're building in the mental health space or you work with communities that are underserved by current AI tools — I'd love to hear from you in the comments.

Solace is an AI companion, not a therapist or medical service. If you are in crisis, please contact your local emergency services.

Which Gemma 4 Model Should You Actually Use? I Tested All of Them, So You Don't Have To

Wed, 03 Jun 2026 11:35:01 +0000

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

Which Gemma 4 Model Should You Actually Use? I Tested All of them, building a Healthcare AI for African Patients

Most model comparison posts are written by people who read the documentation. This one is written by someone who burned through tokens, hit OOM errors, watched Gemini miss clinical signals it should have caught, and eventually landed on the right answer, but only after eliminating everything else first.

I was building Fisibel, a multimodal African synthetic health data platform. The task: upload a real Nigerian hospital record image, extract clinical signals, and generate privacy-safe synthetic datasets grounded in WHO and World Bank statistics. The model had to read handwritten and printed medical documents, understand African-specific clinical patterns, and generate coherent synthetic data at scale.

Here is what I learned by testing every Gemma 4 option available.

Model	Parameters	Architecture	Best For
Gemma 4 E2B	2B effective	Dense	On-device, mobile, offline
Gemma 4 26B MoE	26B total, 4B active	Mixture-of-Experts	Edge inference, deep reasoning
Gemma 4 31B	31B total	Dense	Maximum quality, unconstrained compute

The architectural difference matters more than the number. Let me explain why.

What Mixture-of-Experts Actually Means in Practice
Most explanations of MoE are theoretical. Here is the practical version.
A dense model activates all its parameters for every token it processes. A 31B dense model is doing 31B parameters of work on every single token — whether that token is "the" or "malaria strain variant specific to Lagos State."
A MoE model routes each token through specialized subnetworks called experts. Only a subset activates per token. Gemma 4 26B MoE has 26B total parameters but activates only ~4B per forward pass.
What this means for you:

Inference speed: closer to a 4B model
Knowledge depth: closer to a 26B model
For specialized tasks: the right experts activate for the right content

That last point is the one that changed my project. When processing clinical documents, MoE routes medical terminology, geographic identifiers, and symptom patterns through subnetworks shaped by that kind of content. A dense model processes a Nigerian hospital record exactly the same way it processes a recipe.

Why I Started With Ollama and Had to Stop
The original Fisibel architecture was local inference via Ollama. If the platform handles real hospital record images, keeping inference local meant zero data leaving the machine. Maximum privacy. No transmission risk.
It did not survive contact with reality.
Downloading Gemma 4 locally through Ollama required pulling a model that was simply too large. In Nigeria, where data costs real money, the download cost alone made the pipeline economically unviable. African healthcare researchers operating in bandwidth-constrained environments cannot build on infrastructure that demands gigabytes just to get started.
Lesson: Local inference is the right privacy instinct. But in bandwidth-constrained environments, the data cost of the initial model download is a real barrier, not an abstract one. If you are building for users outside fibre-connected cities, factor this in before you architect around Ollama.
This pushed the pipeline to Google Cloud — not by preference, but by the economic reality of what local inference actually costs when you are not building from San Francisco.

Why I Rejected Gemma 4 31B
Once on cloud inference, the natural assumption was that bigger meant better. Gemma 4 31B was tested first.
It was not better. It was more expensive for the same output.
For clinical signal extraction specifically — reading a hospital record and pulling out diagnoses, symptoms, treatment patterns, geographic identifiers — the 31B model burned tokens significantly faster without producing meaningfully deeper clinical signals than 26B MoE.
The task does not reward raw parameter count. It rewards specialized reasoning over structured medical text. Paying more tokens for marginal returns on a pipeline that needs to run at scale across African health datasets is not a tradeoff worth making.
When to use 31B: Maximum quality tasks where compute cost is not a constraint. Long-form generation. Complex reasoning chains where you need every parameter engaged. Research environments, not production pipelines running at scale.
When not to use 31B: Specialized extraction tasks. Scale-sensitive pipelines. Anything where you will run the model hundreds or thousands of times.

Why I Tested Gemini and What the Results Actually Showed
Gemini was the obvious alternative. Same multimodal capability, faster inference, Google infrastructure. I tested it directly against Gemma 4 26B MoE on the same Lagos hospital record image.
Gemini was faster. On clinical depth, it lost.
The table below shows clinical signals extracted from the same input document across both models:

Clinical Signal Extracted	Gemma 4 26B MoE	Gemini
Primary diagnosis	✅	✅
Comorbidity pattern	✅	✅
Malaria strain variant	✅	❌
LGA-specific risk factor	✅	❌
Regional treatment protocol	✅	❌
Symptom progression timeline	✅	✅
Geographic disease indicator	✅	❌
Age-adjusted risk signal	✅	✅
Local drug resistance pattern	✅	❌
Nutritional comorbidity flag	✅	❌

Gemini caught the general signals. Gemma 4 26B MoE caught the African-specific ones.
No other model in this size class caught all 6 African-specific signals.
This is not a criticism of Gemini. It is a demonstration of what MoE routing does on specialized content. The signals Gemini missed are not obscure — LGA-specific risk factors and regional treatment protocols are standard clinical identifiers in Nigerian medical documents. The difference is in how each model processes domain-specific terminology.
Speed is not always the metric. For specialized extraction tasks, coverage is.
| Use Case | Recommended Model |
| Mobile / on-device / offline | Gemma 4 E2B |
| Specialized domain extraction at scale | Gemma 4 26B MoE |
| Maximum quality, unconstrained compute | Gemma 4 31B |
| Bandwidth-constrained environments | Gemma 4 26B MoE via cloud |
| Research and fine-tuning experiments | Gemma 4 31B |
| Production pipelines with token cost sensitivity | Gemma 4 26B MoE |

Choose Gemma 4 E2B if:

You are building for mobile or on-device
Your users have bandwidth or storage constraints
You need offline capability after the first setup
Your task is classification, routing, or simple generation
You are targeting Android phones under $200

Choose Gemma 4 26B MoE if:

You need reasoning depth at edge-level inference speed
Your task involves specialized domain content — medical, legal, scientific, and regional
You are running at scale, and token cost matters
You need the best quality-to-cost ratio in production
You want MoE expert routing to work in your favour on specialized inputs

Choose Gemma 4 31B if:

Compute cost is not a constraint
You need maximum quality on complex generation tasks
You are doing research, fine-tuning experiments, or one-off analysis
Latency is less important than output quality

The One Thing Nobody Tells You About Thinking Mode
Gemma 4 supports thinking traces. I assumed more thinking meant better answers everywhere. That assumption broke two features before I understood what was actually happening.
Thinking mode helps when the model needs to route across multiple options — tool selection, complex reasoning, and ambiguous queries. It hurts when the task is pure structured output composition. With thinking enabled on a structured generation path, the model spends its entire token budget on internal reasoning traces and produces empty or malformed output.
The rule I now follow: thinking ON for routing, thinking OFF for composition. They are different tasks and the model treats them differently.

What This Means for Open Source AI
Gemma 4 26B MoE running on Google Cloud infrastructure, with no proprietary lock-in, matching or exceeding closed models on specialized domain tasks — that is not a minor footnote. That is the story.
For developers building in bandwidth-constrained environments, for researchers working on underrepresented populations, for anyone who needs frontier-level reasoning without frontier-level costs, the gap between open and closed models just got significantly smaller.
The model I needed to see African clinical signals clearly was not the biggest one. It was not the fastest one. It was the one built to route specialized knowledge to the right place.
That turns out to matter more than size.

I built this while developing Fisibel, a multimodal African synthetic health data platform. The clinical signals table above came from real tests on a Lagos hospital record. All findings are from production pipeline decisions, not benchmarks run for this post.

Coding in the Dark: How Local Gemma 4 Saved My Python Progress During Ukrainian Blackouts

Mon, 25 May 2026 06:54:10 +0000

Hey everyone!

I’m a student developer from Ukraine️, currently diving deep into the worlds of Django and Machine Learning. Like many of you, I spend my days (and nights) battling bugs and learning new frameworks. But there’s one "bug" I can’t fix with a simple pip install: the blackouts️

Because of the ongoing war, our power grid is often under attack. One minute I’m coding a new feature, and the next—total darkness. Silence. No Wi-Fi. No Google. No ChatGPT.

For a long time, this meant my learning just... STOPPED️But then I found a way to keep the "️" of my workstation alive even when the grid is dead!

The Setup: My Local "Senior Developer"

To stay productive in the dark, I’ve moved my AI assistance from the cloud to my local hardware(My ️ is HP ProBook 445 G8).

Here’s how I keep going:

1)The Model: I’m using Gemma 4. It’s incredibly efficient for its size. I downloaded it once, and now it lives on my laptop.

2)The Engine: LM Studio. It’s the easiest way to run local LLMs. It creates a local server on my machine that doesn't need a single byte of internet.

3)The Bridge: e2b. I use it to integrate Gemma directly into my workflow. It’s not just a chat; it’s like having a senior dev sitting next to me, helping me reason through Python logic while the candles are burning.

Why this is a Game-Changer (The Soul Part)

JUST IMAGINE sitting in a pitch-black room. The only light comes from your laptop screen. You’re stuck on a complex Pandas transformation or a Django database migration. Usually, this is where frustration kicks in. You feel isolated️

BUT with Gemma 4 running locally, the conversation doesn't end! I can ask: "Hey dude, why is this Django queryset returning an empty list?️?" and get an instant, intelligent response.️

It’s more than just TECH; it’s about PERSISTANCE! It’s the feeling that no matter what’s happening outside, I can still grow, still learn, and still build. Local AI turned my "dead time️" during blackouts into my most focused study hours️

How I Use It: Two Ways to Stay Online

When you open LM Studio, you actually have two powerful ways to work with Gemma 4, and I use both depending on the task:

1)The AI Chat (Simple & Fast): This is my go-to for quick questions. It’s a clean interface that works exactly like ChatGPT or Gemini. I just select the Gemma model at the top and start asking about Python logic or Django errors. It’s perfect for when I need a quick explanation of a concept while the room is lit only by candles.️

2)The Local Server (For Devs): For more advanced stuff, LM Studio can host a local API server (on localhost:1234). This allows you to connect the model to other tools like e2b or even your code editor. It’s like having an invisible assistant living inside your laptop, ready to process data even without a single byte of internet.

import openai

client = openai.OpenAI(
    base_url="http://localhost:1234/v1", 
    api_key="lm-studio"
)

def get_python_help(query):
    completion = client.chat.completions.create(
        model="google/gemma-4",
        messages=[{"role": "user", "content": query}]
    )
    return completion.choices[0].message.content

print(get_python_help("Explain Django middleware in simple terms"))

Personally, most of the time I just use the AI Chat️ It’s fast, stable, and doesn't waste battery life on complex setups. It just works.

We often think of AI as this "cloud thing" that exists somewhere far away. But Gemma 4 proves that AI can be personal, local, and—most importantly—resilient.

Closing: Why We Keep Building

To everyone reading this, ESPECIALLY those who feel like the world is trying to slow them down: remember that every line of code you write in the dark is a victory. Every bug you fix while the world is silent is a step toward the future you deserve️

"""Our fight for that future that you want isn't with me at chess! It's what you do out there with them!"""

Don't wait for the perfect conditions. Don't wait for the lights to come back on or for the internet to be stable️ The real "GAME" isn't played in the safety of a perfect setup. It’s played right here, in the shadows, where you choose to keep moving forward despite everything.

Local AI like Gemma is more than just a tool—it’s our way of saying that our education and our future are non-negotiable️

Stay hard, stay curious, and keep coding✊️.
See you in the future we’re building right now!!!