DEV Community: Gabriel Mahia

Why Swahili AI Fails at 4 the Rate of English — and How We're Fixing It

Gabriel Mahia — Thu, 04 Jun 2026 11:03:54 +0000

A 2025 benchmark study (arXiv:2509.04516) confirmed what East African AI developers had been observing: general-purpose language models produce 4× more errors in Swahili than English — even for simple factual tasks.

The Root Cause: Data Starvation

Common Crawl, the primary LLM pre-training corpus, is ~50% English and ~0.1% Swahili. That's a 500× data disparity. Models don't fail at Swahili because Swahili is hard — they fail because they've never seen enough of it.

The Compounding Problem

For civic and financial AI in Kenya, it compounds. Kenyan-specific concepts have essentially zero representation:

M-PESA paybill codes and USSD flow formats
KCSE exam structure and curriculum terminology
Kenya Revenue Authority eTims procedures
County government devolution vocabulary

Ask any major LLM to troubleshoot a failed M-PESA B2C payment in Swahili. You'll get plausible confabulation — a payment flow that doesn't match how Daraja actually works.

What We've Built: 110+ Domain-Specific Tools

The East Africa AI portfolio addresses this through three principles:

1. Domain knowledge embedded at the system level

Every tool embeds Kenyan institutional context as baseline knowledge — not retrieval. The model knows what a paybill code is, what KCSE stands for, what the Employment Act says about notice periods.

2. Swahili as first language, not afterthought

"Angalia salio la M-PESA" is not a translation of "Check M-PESA balance" — it's what a Kenyan would actually say. Writing natively instead of translating builds trust with users.

3. MCP infrastructure as force multiplier

By wrapping Kenya's APIs as MCP servers — mpesa-mcp, swahili-health-mcp, kenya-legal-rag — any AI agent inherits correct domain behavior. Tool descriptions are in Kiswahili so agents reason directly from the user's language.

The Data Fix: LINGUA Africa Grant

Long-term fix: better training data. The LINGUA Africa grant application (Microsoft AI for Good Lab × Gates Foundation × Masakhane) targets:

100,000+ labeled Swahili sentence pairs — financial, civic, educational
LoRA fine-tuning of Aya-101 (13B parameters, Apache 2.0)
DPO alignment for accuracy in high-stakes domains
Community evaluation with real M-PESA agents, students, civic journalists in Kenya

Four open datasets are live on HuggingFace now:

gmahia/swahili-civic-nlp — civic and government terms
gmahia/kenya-civic-data — county government data
gmahia/kenya-agricultural-qa — crop and livestock Q&A
gmahia/kenya-legal-nlp — Kenya legal NER annotations

All CC BY 4.0. The tools work today. The grant makes them work better at scale.

Portfolio: gabrielmahia.github.io

HuggingFace: huggingface.co/gmahia

First in East Africa on All Three AI Agent Protocols: MCP, A2A, and Google ADK

Gabriel Mahia — Thu, 04 Jun 2026 11:03:16 +0000

In 2024-2025, three significant AI agent protocols emerged:

MCP (Model Context Protocol) — Anthropic's open standard for tools and data
A2A (Agent-to-Agent) — cross-vendor agent communication protocol
Google ADK (Agent Development Kit) — production agent pipeline framework

Most developers picked one. Most regions had zero implementations of any.

I built all three — for East Africa — and I'm the first documented engineer in the region to do so.

Why All Three?

The ecosystem will consolidate, and first-mover implementations are valuable regardless of which wins. Being the reference for East Africa on all three means the region's infrastructure isn't locked to any single vendor's roadmap.

But practically: each genuinely solves a different problem.

MCP — For Wrapping Existing APIs

MCP is the right choice when wrapping APIs as tool calls an AI agent can invoke directly.

For East Africa:

pip install mpesa-mcp       # M-PESA Daraja API
pip install wapimaji-mcp    # Kenya water infrastructure
pip install swahili-health-mcp  # DHIS2 health data

# Add to Claude
claude mcp add mpesa -- mpesa-mcp
claude mcp add water -- wapimaji-mcp

MCP's value: reducing integration friction per developer to near-zero. The institutional knowledge lives in the MCP server, not in every app built on top.

Result: mpesa-mcp — v0.1.9 on PyPI, 400+ downloads, 12 countries, first African payment API in the MCP ecosystem.

A2A — For Multi-Agent Coordination

A2A is the right choice when multiple specialized agents need to coordinate on complex tasks — negotiating, delegating, sharing context.

For Kenya's civic stack, this means budget accountability that needs a financial agent + legal agent + Swahili summarization agent working together. kenya-a2a handles the message routing and capability advertisement.

Google ADK — For Production Pipelines

ADK is the right choice for production-grade pipelines with evaluation and observability. kenya-adk runs multi-step Swahili advisory workflows with integrated quality evaluation.

The Swahili-First Architecture

All three implementations share one principle: tool descriptions are written in Kiswahili.

When an AI agent receives a Swahili instruction and selects tools, it matches against descriptions. English descriptions introduce a translation step — a failure mode. Swahili descriptions eliminate it:

{
    "name": "mpesa_stk_push",
    "description": "Anzisha malipo ya Lipa Na M-PESA. "
                   "Tumia wakati mtumiaji anataka kulipa kwa M-PESA.",
}

Status

Protocol	Repo	Status
MCP	mpesa-mcp	v0.1.9 · PyPI · 400+ downloads
MCP	wapimaji-mcp, swahili-health-mcp, kenya-legal-rag	Live
A2A	kenya-a2a	Live
ADK	kenya-adk	Live

All MIT licensed. All part of a 110+ tool East Africa portfolio.

The Kenya MCP Hub is a CLI registry for all servers:

pip install kenya-mcp-hub
kenya-mcp-hub list

Portfolio: gabrielmahia.github.io

How I Built an MCP Server for M-PESA — and Why It Matters for East Africa

Gabriel Mahia — Thu, 04 Jun 2026 11:02:16 +0000

Kenya's M-PESA processes $314 billion annually. 35 million users. And until recently, there was no way for an AI agent to interact with it natively.

That changed when I built mpesa-mcp — a Model Context Protocol server that wraps the Daraja API and makes it directly available to Claude, GPT-4, and Gemini.

What is MCP?

Model Context Protocol (MCP) is Anthropic's open standard for connecting AI agents to external tools and data sources. Think of it like REST, but for AI agents — instead of an LLM hallucinating what an API might return, it calls real tools with real data.

An MCP server exposes tools. An AI agent calls those tools. The agent never has to understand the underlying API — it just asks "what tools do you have?" and gets structured results back.

The Problem with M-PESA Integration

M-PESA's Daraja API is well-documented but non-trivial to integrate:

OAuth 2.0 token flow with 1-hour expiry
Request body for STK push includes a base64-encoded password derived from shortcode + passkey + timestamp — regenerated every request
Different base URLs for sandbox vs production
Different authentication flows for STK push, B2C, balance query, transaction status
Error codes are numeric strings, not HTTP status codes

For every developer building an AI assistant on M-PESA, this was ~2 days of integration work before writing a single line of product logic. And every team building their own integration meant every team making the same mistakes with the passkey encoding.

The Solution: mpesa-mcp

pip install mpesa-mcp
claude mcp add mpesa -- mpesa-mcp

That's it. Your Claude instance can now:

Initiate STK push payments (Lipa Na M-PESA)
Execute B2C disbursements
Query account balances
Check transaction status
Register C2B callback URLs

Here's what a tool call looks like from inside the server:

def mcp_call_tool(name: str, arguments: dict) -> dict:
    if name == "mpesa_stk_push":
        token = get_access_token()  # handles OAuth internally
        password = generate_password(shortcode, passkey)  # base64 + timestamp
        return initiate_stk_push(
            token=token,
            phone=arguments["phone_number"],
            amount=arguments["amount"],
            account_ref=arguments.get("account_reference", "Payment")
        )

The MCP server handles the OAuth dance, password generation, and error normalization. The AI agent just says "initiate an M-PESA payment of 100 to 0722000000" and gets a structured result back.

Why "First African Payment API in MCP"

When I shipped mpesa-mcp in 2024, there were hundreds of MCP servers for AWS, GitHub, Stripe, Slack — every major Western tech API. There were zero for African financial infrastructure.

That gap matters. M-PESA isn't just Kenya's payment system — it's the model for mobile money globally. It's processed more transactions than PayPal in some quarters. It operates in Kenya, Tanzania, Uganda, Rwanda, Mozambique, Lesotho, Ghana, and Egypt. And it had no AI agent integration.

mpesa-mcp makes M-PESA a first-class citizen in the MCP ecosystem.

Results

v0.1.9 on PyPI: pip install mpesa-mcp
400+ downloads across 12 countries — without any marketing
PR #7395 on awesome-mcp-servers
Part of a 110+ tool East Africa AI portfolio

What's Next

mpesa-mcp v2.0 will add Swahili-native tool descriptions — so AI agents receiving instructions in Kiswahili can call M-PESA tools correctly without any translation step. This is part of the LINGUA Africa grant application targeting Swahili model fine-tuning.

The repo is MIT licensed and open for contributions.

GitHub: gabrielmahia/mpesa-mcp

PyPI: pypi.org/project/mpesa-mcp

Portfolio: gabrielmahia.github.io

6 weeks later: mpesa-mcp is on the official MCP Registry — here's what I learned

Gabriel Mahia — Tue, 24 Mar 2026 04:12:06 +0000

Follow-up to: Why M-Pesa, Africa's Talking, and USSD are missing from AI agent tooling

Six weeks ago I published mpesa-mcp — an MCP server that gives AI agents access to M-Pesa Daraja and Africa's Talking. Here's what actually happened.

What landed

Official MCP Registry. mpesa-mcp is now listed at io.github.gabrielmahia/mpesa-mcp on registry.modelcontextprotocol.io. This is Anthropic's official registry — the one Claude uses to discover MCP servers. It's the first African fintech entry.

# Install via the registry
uvx mpesa-mcp

punkpeye opened a PR on my repo. punkpeye is the maintainer of awesome-mcp-servers (82k stars). He submitted a PR to add the Glama card badge to the mpesa-mcp README. That's the maintainer of the most-starred MCP directory directly contributing to the project — a signal I did not expect.

v0.1.2 shipped. Changelog:

Fixed a unicode character in glama.json that was causing Glama to reject the file as invalid
Cleaned up the Dockerfile for proper MCP server inspection
Version aligned across pyproject.toml, server.json, and GitHub releases

context-hub PR #52 is still open. The reviewer (@Ivanye2509) asked for structural fixes in March. I fixed them within a week. No response since. Andrew Ng's project appears to have a slow review cadence. The PR is structurally correct, mergeable, and sitting there. If you're reading this and use context-hub — go take a look.

What I got wrong in the original post

I said "submitted to punkpeye/awesome-mcp-servers — the first African fintech entry." That was accurate at submission time.

What I underestimated: the friction involved in actually getting listed. The awesome-mcp-servers bot applies a missing-glama label automatically if the Glama directory doesn't recognise your server. Glama's API was returning 503 for several weeks. A single unicode em-dash in glama.json was causing silent rejection. The listing pipeline is fragile for anyone not already inside the Node/TypeScript MCP ecosystem — which is most of it.

The fix: ASCII-only glama.json, a valid Dockerfile, at least one GitHub release. All documented now in the repo.

What's actually being used

GitHub traffic for the past 14 days: 21 direct views, 18 unique visitors, 190 clones.

The clone-to-view ratio (~9:1) is high — developers are cloning to evaluate rather than browsing. The actions and issues pages are being read, which means people are kicking the tyres on CI and checking whether the project is maintained. The signal that matters: mpesa-mcp is being evaluated by developers, not just scraped by bots.

What I'd do differently

Ship a working sandbox demo earlier. The package works, but the barrier to "see it do something real" is still: get Daraja sandbox credentials, set up environment variables, configure Claude Desktop. That's 30 minutes even for a confident developer. A hosted demo that shows an actual STK Push prompt (Daraja sandbox) with zero setup would have converted more evaluators to users.

Document the phone number normalization problem sooner. The most common Daraja integration bug is phone format: 0712345678 vs 254712345678 vs +254712345678. The server handles all three transparently. I buried this in the README. It should be the first thing developers see.

What's next

Three things on the near horizon:

WapiMaji SMS pipeline needs a registered shortcode. The water stress monitoring app for Kenya has complete Africa's Talking SMS integration — but you need a registered shortcode to actually send to arbitrary Kenyan numbers. That's a $10/month infra cost I haven't pulled the trigger on. When it's live, WapiMaji can SMS drought alerts to farmers on basic phones.
The broader civic tools portfolio. mpesa-mcp is one of 5 open-source packages and 13 deployed tools I've built for East Africa. The full portfolio is at gabrielmahia.github.io. I'll write a separate piece on the civic tools — parliamentary accountability, crop prices, remittance transparency — but the audience for that is different from this one.
daraja-mock v2. The local test server for M-Pesa integrations needs a web UI so non-developers can inspect what the simulated STK Push flow looks like without reading JSON.

If you're building on M-Pesa or Africa's Talking and want to talk about the integration patterns — or if you've encountered the context-hub review wall — reach out.

All tools: gabrielmahia.github.io · mpesa-mcp: github.com/gabrielmahia/mpesa-mcp``

Why M-Pesa, Africa's Talking, and USSD are missing from AI agent tooling — and what I did about it

Gabriel Mahia — Tue, 10 Mar 2026 11:36:37 +0000

I spend a lot of time building tools for Kenya. Payment flows, agricultural alerts, county budget dashboards. The infrastructure layer — M-Pesa, Africa's Talking, USSD — is battle-tested and used by hundreds of millions of people across East Africa.

And yet, when I went to build AI-powered tools that interact with this infrastructure, I found almost nothing. The model context protocol (MCP) ecosystem, which is becoming the standard way AI agents interact with external services, had zero African fintech entries. The context-hub registry — Andrew Ng's project for sharing API documentation as AI-consumable context — had no African payment or telecom providers.

This is the canonical Africa tech gap, but appearing in a new form: the AI tooling layer.

What's actually missing

M-Pesa processes more transactions by volume than PayPal does in Kenya. Africa's Talking reaches developers building on 20+ African telecom networks — Safaricom, MTN, Airtel, Vodacom, Telkom — from a single SDK. USSD (Unstructured Supplementary Service Data) is the dominant self-service channel for banking and government services across the continent, accessible on any phone, no internet required.

When AI agents need to work with payments, they have Stripe, PayPal, Braintree. When they need to send messages, they have Twilio. When they need to understand merchant flows, they have Square.

For any agent building something that actually works in Kenya, Uganda, Ghana, Rwanda — there was nothing.

What I built

Over the past week, I contributed six API documentation sets to context-hub and built an MCP server that gives AI agents direct access to M-Pesa and Africa's Talking.

context-hub contributions (PR #52):

africastalking/sms — bulk send, delivery webhooks, Kiswahili Unicode, county targeting
africastalking/ussd — full session handling, Redis state, bilingual menus, 182-char budget rules
africastalking/airtime — 8-country currency table, NGO payout patterns
safaricom/daraja — STK Push with password generation, C2B, B2C, phone normalization
paystack/payments — Nigeria/Ghana/Kenya/SA, HMAC webhook, mobile money, split payments
mtn-momo/collections — 17-country coverage, async polling, PUT webhook pattern

If these get merged, any developer using Claude Code, Cursor, or Copilot who runs chub get safaricom/daraja will get production-quality documentation as structured context. The patterns for STK Push authentication (the base64 password generation with timestamp is non-obvious), webhook verification, and phone number normalization (every Kenyan format maps to a different E.164 variant) are exactly the things that aren't documented clearly anywhere.

mpesa-mcp:

The MCP server (pip install mpesa-mcp or uvx mpesa-mcp) gives AI agents five tools:

mpesa_stk_push           — trigger payment prompt on customer's phone
mpesa_stk_query          — check STK Push status
mpesa_transaction_status — query any M-Pesa transaction by receipt
sms_send                 — 1–1,000 recipients across 20+ African networks
airtime_send             — programmatic airtime top-up

It's submitted to punkpeye/awesome-mcp-servers — the first African fintech entry in that list (82k stars).

Why this matters beyond the tools themselves

African developers are dramatically underrepresented as contributors to AI infrastructure. The tools being built to power the next generation of AI applications are being built by and for markets with credit cards, Stripe accounts, and Twilio numbers. The result is predictable: agents that can't operate in the markets where the infrastructure is completely different.

The gap isn't technical — the M-Pesa API is well-designed, Africa's Talking is developer-friendly. The gap is presence. Nobody put in the work to document these APIs in the formats that AI tooling consumes.

That's a fixable problem.

What's next

The context-hub PR needs to merge. If it does, the distribution is significant — every Claude Code and Cursor user who runs chub get will have access to it.

I'm also building out the library layer: daraja-mock (local test server so you can develop M-Pesa integrations without a Safaricom account), kenya-sms (bilingual EN/Kiswahili SMS templates), pesa-cli (command-line M-Pesa operations). These packages make building African fintech applications feel like building anything else — installable, testable, documented.

The goal is to make "I'm building an app in Kenya" feel like a first-class engineering problem rather than a research project.

Tools: mpesa-mcp · context-hub PR · awesome-mcp-servers PR

Full ecosystem: github.com/gabrielmahia