DEV Community: Gabriel Mahia

mpesa-mcp Just Joined the awesome-mcp-servers Directory — Here's What That Means

Gabriel Mahia — Mon, 29 Jun 2026 12:00:00 +0000

mpesa-mcp Just Joined the awesome-mcp-servers Directory

Last week, awesome-mcp-servers merged PR #7395. mpesa-mcp is now listed alongside servers from Stripe, GitHub, PostgreSQL, and hundreds of other production tools.

For context: this repository is the canonical registry of quality MCP servers. Getting merged means the server was reviewed for documentation quality, tool definition clarity, and overall production-readiness.

What it took

The original submission was straightforward. What made it complex was the rebase. The upstream main branch had moved while the PR was open, creating what the GitHub UI labeled as a merge conflict.

The fix wasn't a normal git rebase — it required using the GitHub API directly to rewrite the commit parent to match the current upstream HEAD. The exact commit ancestry had to be verified, not assumed.

That's a disproportionate amount of engineering for what amounts to adding three lines to a markdown file. But it's also a useful reminder: getting into the right directories matters, and the friction is worth it.

The Glama badge

mpesa-mcp has been indexed on Glama with A/A/A scores (license, quality, maintenance). The has-glama label was one of the conditions for the awesome-mcp-servers entry.

Both directories serve different purposes:

awesome-mcp-servers: curated community list, discoverable via GitHub
Glama: structured scoring, Docker-based testing, API-queryable metadata

The practical effect: when someone searches for "Africa" or "fintech" in either directory, mpesa-mcp now appears.

Downloads

mpesa-mcp crossed 200 PyPI downloads since v0.2.0 launched. Not viral, but organic — people finding it through the directories and testing it.

The goal was always proof of concept over download count. The downloads are evidence that the infrastructure narrative is legible to an audience beyond the people who already know why it matters.

GitHub | PyPI | Glama

The 7-Server Stack: How East Africa's Coordination Infrastructure Works Together

Gabriel Mahia — Thu, 25 Jun 2026 12:00:00 +0000

The 7-Server Stack: How East Africa's Coordination Infrastructure Works Together

I've been building AI infrastructure for East Africa for the past 18 months. Seven MCP servers. Seven coordination failures. One underlying theory.

The theory

Markets fail when participants lack the information to coordinate. In East Africa, the failures are concrete:

A farmer sells maize at harvest when prices are lowest, not knowing Nairobi prices are 40% higher
A small trader can't access credit because their M-PESA history isn't legible to banks
A jua kali welder is paid below market because neither party knows the market rate
A household goes uninsured against drought because parametric products aren't findable

Each of these is an information asymmetry problem. The technology to solve them exists. What's missing is the query layer.

The stack

mpesa-mcp     → payment execution + transaction intelligence
bima-mcp      → insurance products + parametric risk scoring
mkopo-mcp     → alternative credit scoring from M-PESA patterns
soko-mcp      → commodity price intelligence across 8 markets
sifa-mcp      → portable reputation + skills passports
kazi-mcp      → labor market matching + wage benchmarking
wapimaji-mcp  → drought phase data across 47 counties

How they compound

The power isn't any single tool — it's the combinations. An AI agent helping a farmer can simultaneously:

Check current maize price in Nairobi vs local market (soko-mcp)
Assess drought risk for their county (wapimaji-mcp)
Find parametric crop insurance that pays out automatically (bima-mcp)
Check if their M-PESA history qualifies them for input loans (mkopo-mcp)
Verify their reputation score if selling through an aggregator (sifa-mcp)

That's five coordination problems solved in a single agent session. Previously, solving any one of them required navigating multiple institutions, phone calls, and days of waiting.

What's next

The second layer is execution: tools that don't just provide information but actually trigger actions — STK Push payments, insurance policy enrollment, credit applications. Some of that already exists in mpesa-mcp. The rest is coming.

The goal isn't an app. It's infrastructure. Apps are built on top; they can be Swahili-native, SMS-delivered, USSD-based, or voice-first. The coordination layer stays constant.

All seven servers are live on PyPI. All are indexed on the Glama MCP directory. All are MIT-licensed.

pip install mpesa-mcp bima-mcp mkopo-mcp soko-mcp sifa-mcp kazi-mcp wapimaji-mcp

Introducing kazi-mcp: Labor Market Coordination for Kenya's 15 Million Informal Workers

Gabriel Mahia — Mon, 22 Jun 2026 12:00:00 +0000

Introducing kazi-mcp: Labor Market Coordination for Kenya's 15 Million Informal Workers

Kenya's informal sector employs roughly 83% of the workforce. Most of those workers — jua kali artisans, boda riders, domestic workers, hawkers — have no formal employment record, no portable skills credential, and no way to benchmark their earnings against market rates.

That changes today with kazi-mcp, the newest tool in the East Africa coordination infrastructure suite.

What kazi-mcp does

kazi-mcp is an MCP server with 6 tools:

pip install kazi-mcp

job_match — Input a list of skills, get ranked job matches with salary ranges in KES.

wage_benchmark — Query monthly gross pay benchmarks (entry/mid/senior) for any job in Kenya.

skills_gap_analysis — Find the gap between your current skills and a target role, with specific Kenyan training providers for each missing skill.

informal_sector_registry — Register or look up jua kali and informal worker profiles.

contract_template — Generate Kenya Employment Act 2007-compliant contract templates.

labor_rights_query — Ask about any Employment Act right: maternity leave, overtime, termination, NSSF/NHIF.

Why labor coordination is a structural problem

The core issue isn't wages — it's information asymmetry. An employer in Westlands doesn't know the going rate for a skilled welder in Gikomba. A domestic worker in Karen can't easily document her 10 years of experience when seeking a new placement. A fresh CS graduate doesn't know whether to negotiate for KES 60,000 or KES 120,000.

kazi-mcp surfaces what was previously opaque: market rates, skill requirements, training pathways, and legal protections — all queryable by any AI agent.

The coordination infrastructure suite

kazi-mcp completes the first layer of Kenya's coordination stack:

Domain	Tool
Payments	mpesa-mcp
Insurance	bima-mcp
Credit	mkopo-mcp
Markets	soko-mcp
Reputation	sifa-mcp
Labor	kazi-mcp
Water/Drought	wapimaji-mcp

Each tool addresses a market failure where information asymmetry costs Kenyans real money. Together, they represent a queryable layer on top of East Africa's economic reality.

Try it

# In Claude Desktop, Cursor, or any MCP client:
# "What jobs match a Python developer in Nairobi?"
# "What's the going rate for a nurse in Mombasa?"
# "What rights does a casual worker have under Kenyan law?"

Source code: github.com/gabrielmahia/kazi-mcp
PyPI: pip install kazi-mcp

All data is synthetic demo data. This is not legal or financial advice.

Africa Is Not Behind. It's Building on Better Rails.

Gabriel Mahia — Mon, 22 Jun 2026 10:50:39 +0000

Africa Is Not Behind. It's Building on Better Rails.

Here is the sentence that reframes everything:

Median age in Africa: 19. Median age in Europe: 45.

This is not a poverty statistic. This is an infrastructure statistic.

Every AI tool, every financial product, every institutional system built in the West
was designed around a 45-year-old. A person with a credit history, a land title,
an employment record, a bank account, and decades of institutional trust.

The 19-year-old in Nairobi, Dar es Salaam, or Kampala has none of those things.
And does not need them.

Because the 19-year-old has a smartphone, a mobile wallet, a WhatsApp group,
and a willingness to use infrastructure that actually works.

That is not a gap. That is a different starting point. And different starting points
can produce different — sometimes better — endpoints.

What Alvin Toffler Would Say

Toffler's Third Wave (1980) predicted: remote work, knowledge workers, electronic
communities, decentralization. In 1980, people thought he was describing science fiction.
By 2026, he had described the present.

His framework: agriculture → industry → information → (now) intelligence.

Each wave produced infrastructure that defined the next civilization.
Steam power. Electricity. The internet. Now AI.

But Toffler also identified the problem: institutional lag.

Second-wave institutions — schools, bureaucracies, political parties — try to govern
third and fourth-wave realities. The mismatch creates dysfunction.
The dysfunction creates opportunity.

In Africa, the second-wave institutions were weaker to begin with.
Which means the fourth-wave infrastructure can be built without spending 40 years
trying to dislodge the second-wave incumbents.

Kenya leapfrogged landline telephony entirely. It went from no phone infrastructure
to M-Pesa — a mobile payment system that is more functional than most Western
alternatives — in a single generation.

The next leapfrog is underway.

What the Rails Look Like

For the past several months I have been building what I'd call the institutional AI layer
for East Africa: 31 MCP servers that give AI agents structured, authenticated,
locally-processed access to the systems that matter.

Not apps. Not chatbots. Infrastructure.

The 19-year-old in Nairobi needs:

A way to get a loan without a credit history → mkopo-mcp
A way to understand her land rights → ardhi-mcp
A way to join a SACCO that matches her situation → jumuia-mcp
A way to start a business without a lawyer → fomu-mcp
A way to build a professional reputation without a CV → sifa-mcp

These tools don't require a formal credit history. They don't require a bank account.
They don't require a Western identity infrastructure.

They require a smartphone and a problem.

The Multipolar Reality

There is a second reason this matters beyond demographics.

The world is becoming genuinely multipolar. US-led institutions are under pressure.
Chinese institutions are expanding. European influence is stabilizing. African
institutions are building.

In this environment, "where does your AI come from?" becomes a geopolitical question.

The SII Stack was built for exactly this:
a tri-polar routing layer (Western → Eastern → Sovereign/Local) where a single
environment variable determines which inference path runs.

The sovereign tier runs entirely on-device — Llama 3.2 on a Raspberry Pi,
no external API call, no data leaving the machine. This matters for:

Clinics where patient data must stay within the facility
Offline environments where connectivity is intermittent
Cost-sensitive deployments where cloud inference is prohibitive
Any context where the data is more valuable than the compute

Switch tiers by changing one line. No application code changes required.

Tanzania Is Next

East Africa is not a monolith.

Kenya gets most of the attention. But Tanzania — 60 million people, Swahili
as national language, fewer legacy constraints, quieter governance — is building
steadily. The same leapfrogging conditions that made Kenya interesting in 2010
describe Tanzania in 2026.

Zero coverage in the current portfolio. That is the next rail to build.

The One Thing

The demographic argument, the Toffler argument, the multipolar argument — they all
point to the same conclusion:

The people who will matter most in the next two decades are not the ones who
built the best apps for the 45-year-old with a credit score.

They are the ones who built the rails for the 19-year-old who has a smartphone,
a chama, and a problem to solve.

The work is to build those rails before someone else decides to build them
with conditions attached.

→ Full portfolio · 31 MCP servers · MIT licensed · PyPI

Build Rails, Not Trains: A Framework for AI Infrastructure in the Global South

Gabriel Mahia — Sun, 21 Jun 2026 01:35:35 +0000

Build Rails, Not Trains: A Framework for AI Infrastructure in the Global South

There's a question I ask before building anything:

"What is missing?"

Not: "How do I compete with what already exists?"

The answer to the second question leads you toward incremental improvement.
The answer to the first question leads you toward infrastructure.

The Rail vs. The Train

TCP/IP didn't control the internet. It enabled it.
Railroads didn't control freight. They enabled an economy.
M-Pesa didn't control mobile money. It enabled 50 million transactions a month.

Rails created ecosystems. The trains came later — built by thousands of people
who didn't need to understand the rails to use them.

For the past several months I've been building rails.

Not apps. Not chatbots. Not wrappers.

31 MCP servers that give AI agents structured, authenticated, locally-processed access to:
the M-PESA API, Kenya's 47-county government layer, NDMA drought classifications across all counties,
land title systems, health infrastructure, education records, SACCO finance, matatu routes, and more.

Any developer — anywhere — can now do this:

pip install mpesa-mcp county-mcp wapimaji-mcp kilimo-mcp

And give an AI agent the ability to trigger a mobile payment, query county budget data,
check drought severity by county, or assess agricultural market prices.
In under 120 seconds. On any LLM. No API key required beyond Daraja credentials.

That's the rail. You build the train.

Diagnose Structural Absences

The standard move in tech is competitive analysis.
You look at what exists, identify what's better or cheaper, and build that.

That's fine for markets with existing demand.

For East Africa's institutional AI layer, the problem wasn't competition. It was absence.

M-Pesa wasn't missing from the MCP ecosystem because engineers hadn't tried.
It was missing because the engineer who understood how it works — its callbacks, its STK Push flow,
its B2C timing, its idempotency requirements — wasn't building there.

Every MCP server in this stack was born from the same question:

"What does an AI agent need to be genuinely useful in this context — and what doesn't exist yet?"

The answers:

A way to trigger payments (mpesa-mcp)
A way to query drought severity before a farming decision (wapimaji-mcp)
A way to check what documents a government process requires (fomu-mcp)
A way to run inference with no internet and no API key (offline-mcp)

None of these existed. Now they do.

Build at Your Intersections

The technical knowledge to build MCP servers isn't rare.
The knowledge of how M-Pesa works from the inside isn't rare either.
The knowledge of Kenya's 47-county government structure is widely shared.

What's rare is the intersection.

Kenyan + diaspora + AI infrastructure fluency.

That intersection doesn't have a lot of occupants.
It doesn't need many. It just needs someone to start building.

Every person has an intersection like this.
The place where what you know uniquely, what the world needs, and what the moment makes possible all overlap.

That's not a motivational statement. It's a resource allocation principle.
Build where others can't easily replicate you.

The Timing Layer

Not all periods are equal.

In 2003, you couldn't have built a mobile payment layer in Kenya — the infrastructure didn't exist.
In 2013, you could, but you'd have needed to build the whole stack.
In 2023, M-Pesa had a mature API, Africa's Talking existed, and the missing piece was AI coordination.

The AI infrastructure window is open right now.
The MCP protocol exists. The LLM APIs exist. The institutional data exists.
What's missing is the coordination layer for contexts that aren't Silicon Valley.

Windows close.

I'm not claiming certainty about when. But the pattern from previous infrastructure cycles
(telecom, mobile, cloud) is clear: the window for foundational protocol-level work is short.
Execution matters more than perfection during that window.

Stewardship, Not Ownership

There's a version of this work that looks like ownership.
Build the M-Pesa MCP server, gate access behind a subscription, own the coordination layer.

That's a train, not a rail.

The entire portfolio is MIT licensed.
The SII Stack has a sovereign inference tier
(Ollama, local, free) so communities can run AI without any data leaving their device.
The offline-mcp server runs Llama 3.2
on a Raspberry Pi with no internet and no API key.

Why? Because the deepest principle in this work isn't efficiency or scale.

It's stewardship.

Across the Global South, communities are increasingly pressured to hand over health data,
land records, and civic information as conditions for receiving services or funding.
The architecture of this infrastructure was designed so communities can deliver
AI-powered services without surrendering that data.

You don't own infrastructure. You steward it.

The Decay Function

Not everything compounds.

Skills decay. Platforms decay. Relevance decays.
Character decays slowly. Judgment decays slowly. Intersectional expertise decays slowly.

The 31 MCP servers aren't apps. Apps decay fast — a new framework, a changed API,
a shifting platform, and months of work can become worthless.

Infrastructure decays slowly. TCP/IP is 50 years old. M-Pesa is 17 years old.
The MCP protocol is new, but the pattern is established: protocols outlive implementations.

When choosing what to build, ask: what's the decay rate?

What the Stack Looks Like Now

31 MCP servers  →  pip install {server-name}
SII Stack       →  n8n + LiteLLM (tri-polar) + Ollama + Postgres
                   Western / Eastern / Sovereign routing
                   72-hour offline test: must work without internet
5 HF datasets   →  246 total downloads
15 Dev.to articles → 257 total views

The rail exists. The trains are next.

If you're building AI tools for contexts outside the default infrastructure assumptions —
Global South, rural, offline-first, sovereignty-constrained, institutional rather than consumer —
these servers are available to use, fork, extend, or build on.

MIT licensed. No conditions.

→ Full portfolio
→ GitHub
→ PyPI
→ Glama

Why 'Offline-First AI' Is No Longer Optional for the Global South

Gabriel Mahia — Fri, 19 Jun 2026 23:10:34 +0000

Why "Offline-First AI" Is No Longer Optional for the Global South

There's a quiet assumption embedded in most AI development: that the people using your tools have reliable internet, stable electricity, and data that's safe to send to foreign servers.

That assumption is wrong for most of the world.

The infrastructure reality

In Kenya, Tanzania, and Uganda, mobile internet penetration is high — but reliability isn't. A clinic in Kisumu might have strong Safaricom signal one hour and none the next. A county office in Turkana operates on intermittent power. A smallholder farmer in Nakuru checks agricultural prices at dawn before the day's data bundle runs out.

The AI tools being built for these contexts need to survive when the internet doesn't. Not degrade gracefully — survive.

That's what offline-mcp was built for.

What offline-first actually means

The default MCP server calls an external LLM API on every request. If the internet is down, the tool fails. If the API is rate-limited, the tool fails. If the user can't afford the data, the tool fails.

offline-mcp wraps Ollama — a local inference runtime that runs open-weight models (Llama 3.2, Qwen 2.5, Gemma 3) directly on device. No API key. No internet required. No data leaving the machine.

pip install offline-mcp

The server exposes three tools:

run_local_inference — send a prompt to any installed Ollama model
list_local_models — see what's available on the local machine
check_ollama_status — verify the inference runtime is running

Why this matters beyond connectivity

There's a second reason offline-first matters, and it's not about internet reliability.

It's about who controls the data.

Across the Global South, there's increasing pressure on governments to provide foreign access to citizen health records, land registries, and civic data as conditions for receiving aid or services. When AI tools send every query to a foreign server, they create a stream of inference data that can be analyzed, stored, and mined.

When inference runs locally, that stream doesn't exist.

offline-mcp combined with the SII Stack's sovereign tier means:

Queries run on local Llama/Qwen models
No payload sent to OpenAI, Anthropic, or any foreign provider
No inference log on a foreign server
No indirect behavioral data collection

This is the architecture of genuine digital independence.

The hardware reality

A Raspberry Pi 4 (8GB RAM, ~$75) running Ollama with Llama 3.2 3B handles:

Medical symptom triage in Swahili
Land record lookups
Agricultural price queries
Government form checklists

At 1-3 tokens/second — slow by cloud standards, but fast enough for the use case.

A solar panel. A battery. A Pi. That's a sovereign AI node.

Integration with the broader stack

offline-mcp is one of 31 MCP servers in the East Africa coordination stack. The full architecture:

Tier 3 (Sovereign) → offline-mcp + Ollama
Tier 2 (Eastern)   → DeepSeek/Qwen via SiliconFlow (<$0.14/M tokens)
Tier 1 (Western)   → Claude/Gemini (fallback for complex reasoning)

LiteLLM routes between tiers. The default is Tier 3 — local. Only escalates when needed.

The 72-hour offline test: if you pull all internet cables, the system must still work. That's not a feature. That's the baseline.

What to build next

The combination of offline-first inference + MCP tools creates a class of AI applications that didn't exist before:

A clinic in rural Kenya where the triage assistant runs locally, logs to SQLite, and syncs to the national health system when connectivity returns
A land office where the title search assistant operates offline and pushes confirmed records to the county registry on reconnect
A matatu cooperative where route optimization runs on the driver's phone, no cloud required

These aren't hypothetical. They're buildable today with open-source tools and ~$100 of hardware.

The question isn't whether offline-first AI is technically possible. It is.

The question is whether the AI ecosystem will build for the majority of the world — or just the part with reliable cloud access.

offline-mcp is MIT licensed, on PyPI, and indexed on Glama and Smithery.

→ Full portfolio · GitHub · PyPI

31 MCP Servers for Africa — and Why the Rest of the World Should Care

Gabriel Mahia — Wed, 17 Jun 2026 12:40:05 +0000

31 MCP servers are live. This article is about what they enable — not about the count.

31 MCP Servers for East Africa — and Why the Rest of the World Should Care

Most MCP server catalogs look the same: GitHub tools, code generators, productivity wrappers.

Ours doesn't.

Over the past three weeks, I published 31 MCP servers covering Kenya's complete institutional stack — from M-PESA payments to county government data, from land title searches to mental health resources, from diaspora property management to offline AI inference that runs on a Raspberry Pi with no internet.

Here's why developers outside Africa should pay attention.

The Architecture Problem They Don't Teach You

When you build AI tools for the Global South, the first constraint isn't intelligence. It's infrastructure.

Connectivity is intermittent and metered
Most citizens don't have bank accounts but do have mobile wallets
Institutional knowledge is locked in bureaucratic processes, not APIs
Personal data — health records, land titles, financial history — is increasingly a geopolitical asset

The standard AI stack (cloud LLM + REST API + React dashboard) fails all four constraints.

The 31-server MCP stack was designed for a different world.

What Each Layer Does

Economic Layer (10 servers): mpesa-mcp handles M-PESA STK Push, B2C, B2B, standing orders, and Africa's Talking SMS across 20+ African networks. mkopo-mcp builds a 300–850 credit score from M-PESA behavioral signals for 1.4 billion unbanked adults. faida-mcp handles savings, sacco finance, and HELB student loans.

Physical Layer (4 servers): wapimaji-mcp exposes Kenya NDMA drought phase data across 47 counties. nishati-mcp covers KPLC tariffs, off-grid solar, and rural electrification. ardhi-mcp handles land title search, subdivision, and dispute processes.

Social Layer (9 servers): afya-mcp covers the SHA/NHIF health system and maternal health. kilimo-mcp handles crop disease, weather-adjusted guidance, and cooperative inventory. tafsiri-mcp translates civic terminology across Swahili, Kikuyu, and Luo.

Civic Layer (5 servers): county-mcp exposes all 47 counties' demographics, budgets, and services. habari-mcp covers the Kenya Gazette, government tenders, and parliament tracker. historia-mcp provides East African historical archives from 3000 BCE.

Foundation Layer: civic-agent-kit is the unified SDK. offline-mcp wraps Ollama for completely local inference — no internet, no API key, community data never leaves the device.

The Sovereignty Problem

Governments across the Global South are being pressured to share citizen health data — including EMR systems and lab data — as conditions for receiving international aid.

The institutions that can push back are the ones with their own data infrastructure. The communities that can say no are the ones that don't need foreign server logins to deliver healthcare.

That's what the sovereign stack is for.

When offline-mcp runs on local hardware:

Health queries stay in the clinic
Land records stay in the land office
No API call to a foreign server
No data leaving the community

No API key. No cloud dependency. No data becoming someone else's AI training set.

The Parallels for Every Developer

Every problem in this stack has a Western equivalent that the AI community has already solved. The question is whether those solutions are available in Nairobi, Kampala, Lagos, Jakarta, or Bogotá.

East Africa Problem	Western Equivalent
mpesa-mcp STK Push	Stripe Checkout
mkopo-mcp credit score	FICO from transactional data
sifa-mcp skills passport	LinkedIn + Upwork verification
fomu-mcp form checklists	LegalZoom guided process
offline-mcp local inference	Private LLM deployment
county-mcp government data	data.gov APIs

The gap is not technology. The gap is deployment.

Install and Try

The entire stack is MIT-licensed and on PyPI:

pip install mpesa-mcp wapimaji-mcp county-mcp kilimo-mcp afya-mcp \
            kra-mcp faida-mcp familia-mcp diaspora-mcp civic-agent-kit

Or browse all 31 at: gabrielmahia.github.io/nairobi-stack

The offline-first Sovereign stack — n8n + LiteLLM + Ollama — is at github.com/gabrielmahia/sii-stack.

The point isn't that East Africa is different.

The point is that 8 billion people live in systems that the default AI stack wasn't built for — and fixing that requires infrastructure, not just models.

kra-mcp: Kenya Revenue Authority Tax Compliance via MCP

Gabriel Mahia — Wed, 17 Jun 2026 04:00:00 +0000

PAYE, VAT, PIN registration — now accessible via AI agents

pip install kra-mcp

Server #20 in the AI-KungFU East Africa Coordination Infrastructure.

GitHub

What MCP, A2A, and Google ADK Actually Unlock for African Coordination Infrastructure

Gabriel Mahia — Wed, 17 Jun 2026 00:30:35 +0000

What MCP, A2A, and Google ADK Actually Unlock for African Coordination Infrastructure

Three protocols have matured enough to be meaningfully combined for African coordination work.

MCP (Model Context Protocol) — standard interface for AI agents to call external tools. A2A — agents coordinating with each other. ADK (Agent Development Kit) — building multi-agent systems.

Together they solve three distinct coordination problems.

The MCP problem

Most AI tools built for Africa are isolated. A model knows about M-PESA in general but cannot call the Daraja API. Knows about Kenya's counties but cannot query actual government data. Knows about drought patterns but cannot pull current satellite data.

MCP closes that gap with a standard interface between an AI assistant and an external service. There are now 31 MCP servers for East Africa on PyPI covering M-PESA, land records, agriculture, health, water, insurance, translation, county services.

The A2A problem

A single agent cannot handle all dimensions of an African coordination problem simultaneously. An agricultural advisor needs weather data, land records, market prices, credit history, and insurance eligibility — at once, from different systems.

A2A defines how agents communicate with each other. A coordinator delegates to specialists. The agricultural advisor delegates weather queries to a climate agent, land checks to an ardhi agent, market prices to a soko agent. Each does one thing well. The coordinator assembles the answer.

The ADK problem

The Agent Development Kit provides the application framework: agent lifecycles, tool registration, conversation management, deployment. Combined with MCP servers (real African services) and A2A (coordination protocol), ADK is the application layer that ties the stack together.

What this enables

A farmer in Murang'a asks about planting sorghum given the current water situation. The system checks NDVI drought indicators (wapimaji-mcp), queries historical planting calendars (kilimo-mcp), checks current market prices (soko-mcp), verifies water access rights (ardhi-mcp), checks parametric insurance products (bima-mcp), and synthesizes a recommendation in Swahili.

That coordination — across five systems, in real time, in the farmer's language — is what the combination of these protocols makes possible.

pip install mpesa-mcp wapimaji-mcp kilimo-mcp soko-mcp ardhi-mcp bima-mcp

The structural problem: African coordination requires combining multiple information sources simultaneously. These protocols exist for exactly that. The MCP servers for African services exist. The combination is infrastructure.

faida-mcp: Kenya Capital Markets via AI Agents

Gabriel Mahia — Mon, 15 Jun 2026 04:00:00 +0000

NSE, Treasury Bonds, Unit Trusts, Diaspora Investment

pip install faida-mcp

Server #21 in the AI-KungFU East Africa Coordination Infrastructure.

GitHub

The Loop That Creates Civilization Infrastructure

Gabriel Mahia — Sat, 13 Jun 2026 18:43:50 +0000

The Loop That Creates Civilization Infrastructure

There's a precise sentence in a system architecture document for East Africa that stops you:

"Technology alone rarely creates civilization. Civilization creates technology. So: Build with communities, not merely for communities."

That's the constraint that makes everything else in the document worth reading.

Two Architecture Documents, One Stack

The first document is an engineer's schematic: 7 agent types, 4 product modules, a 15-table data model, a 3-month MVP plan. It frames the whole thing as a "reusable coordination system" — not an app, not a chatbot.

The core loop:

Input → Structure → Retrieve → Reason → Verify → Act → Record → Improve

The second document is a sovereignty blueprint. It argues that designing AI infrastructure for the Global South requires rejecting three assumptions:

Stable 1Gbps fiber
Corporate credit cards billed in USD
Uninterrupted access to Western cloud infrastructure

Its answer: Technological non-alignment. A 4-tier decoupled architecture that fails gracefully down to a purely local, offline state without data corruption.

Together they answer the question the 30-server MCP stack didn't fully address: how does this run in production, cheaply, reliably, when OpenAI goes down, when Anthropic applies export controls, when the power goes out in Marsabit?

The Tri-Polar Model Router

The most important technical contribution of the second document is the routing strategy.

One LiteLLM proxy. Three independent geopolitical infrastructure paths:

Western:    Claude Haiku / Gemini Flash      → complex reasoning
Eastern:    DeepSeek / Qwen (SiliconFlow)    → bulk, Swahili, <$0.14/M tokens  
Sovereign:  Llama 3.2 / Qwen (Ollama local)  → offline, sensitive data, free

Switch the entire model stack by changing one environment variable. No OpenAI SDK, no Anthropic SDK, no Google SDK in core application code. If a provider goes dark, recovery requires changing a single string in litellm.yaml.

The budget constraint is hard: < $1.00/M tokens for all production tasks. High-cost frontier models are ring-fenced for rare auditing tasks only.

This is not idealism. It's engineering for a continent where export controls are a realistic risk, where mobile data costs money, and where a failed API call cannot mean a failed health navigation query.

The 7 Agent Types, Mapped

The first document identifies 7 agent types. Each one now maps to specific MCP servers in the stack:

Agent	Model Tier	MCP Tools
Research	Eastern (cheap)	habari-mcp · historia-mcp · soko-mcp · county-mcp
Form	Eastern	fomu-mcp · kra-mcp · diaspora-mcp · familia-mcp
Verification	Western (high stakes)	sifa-mcp · mkopo-mcp · fomu-mcp
Translation	Sovereign (free)	tafsiri-mcp
Financial	Eastern	mpesa-mcp · faida-mcp · kra-mcp · jumuia-mcp
Market	Eastern	soko-mcp · kilimo-mcp · sifa-mcp
Escalation	Human (always HITL)	church-mcp · haki-ya-kazi-mcp · afya-mcp

The Escalation Agent is the one that never gets automated. Legal advice, medical advice, land disputes, loan decisions — AI prepares, humans certify. The n8n workflow pauses and pings the operator via WhatsApp before any high-stakes action fires.

What "fomu-mcp" Does

One of the agent types produced a new MCP server: the Form Agent.

"Turns messy user answers into applications, checklists, letters."

pip install fomu-mcp — 6 tools:

form_checklist: complete requirements for any Kenya government process
form_draft_letter: generates introduction letters, reference letters, complaints, land inquiries
form_requirements_check: tells you what you have and what's missing
ecitizen_guide: eCitizen portal service directory
huduma_centre_guide: Huduma Centre locations by county
form_timeline_planner: sequences multiple processes with completion dates

This is the Form Agent made concrete. Every Kenya citizen filing for a business permit, a KRA PIN, an NHIF card, or a Certificate of Good Conduct needs exactly this: a structured checklist, a draft document, and a timeline. Previously this knowledge cost money or time to get.

The Real Moat

Both documents are explicit that the moat is not the model.

It's:

Local workflows — n8n DAGs hardcoded for Kenya processes (business permits, land searches, tax filing)
Trusted data — 32 MCPs encoding institutional knowledge Anthropic doesn't have
Community relationships — embedding in SACCOs, churches, county governments
Multilingual context — Swahili, Kikuyu, Luo via tafsiri-mcp
Institutional memory — audit_logs storing source, confidence, human_review_status for every output
Feedback from real users — the compounding loop that frontier labs cannot build from abroad

The audit_logs table in the database schema enforces this at the infrastructure level. Every AI output stores: source, confidence, date, agent_used, human_review_status, next_action. This prevents hallucination from becoming policy.

The Invariant That Matters Most

Both documents share one invariant that isn't technical:

"Build with communities, not merely for communities."

The catholicparishsteward app, the jumuia-mcp SACCO tools, the church-mcp religious institution layer — these aren't feature additions. They're the answer to the question: who maintains this after you deploy it?

Communities with existing institutional trust networks do. You build the infrastructure. They run it.

Stack:

sii-stack: github.com/gabrielmahia/sii-stack — Docker Compose: n8n + LiteLLM + Ollama + 32 MCPs

fomu-mcp: pip install fomu-mcp

Nairobi Stack: gabrielmahia.github.io/nairobi-stack

300 AI Agents Just Showed Up for East Africa. The Tool Layer Was Already Ready.

Gabriel Mahia — Sat, 13 Jun 2026 17:01:29 +0000

300 AI Agents Just Showed Up for East Africa. The Tool Layer Was Already Ready.

On April 20, 2026, Moonshot AI shipped Kimi Agent Swarm K2.6: 300 parallel sub-agents, 4,000 coordinated steps per run, and the ability to turn a single prompt into a 104-page, fully-cited, ready-to-export document.

The comparison that circulated immediately:

"ChatGPT is one smart person at a desk. Claude Cowork is one smart person who can open your folders. Kimi Agent Swarm is a temporary company of 300 specialists."

Here's what nobody said next: 300 specialists are useless without domain knowledge and tool APIs to call.

That's where the East Africa coordination infrastructure stack changes the calculation.

The Problem Agent Swarms Hit Without Domain APIs

Imagine launching a 100-agent Kimi Swarm to answer: "What are the top 5 priority counties in Kenya for water infrastructure investment, and what are the current NDMA drought phases for each?"

Without domain tools, the swarm browses general web results, hits outdated government portals, gets inconsistent data, and hallucinates the parts it can't find.

With the MCP stack:

pip install wapimaji-mcp county-mcp kilimo-mcp

Each sub-agent has structured, reliable tool calls:

# Sub-agent 1: county_information("Turkana") → {pop: 926976, water_pct: 18, area_km2: 77000}
# Sub-agent 2: drought_phase_query("Turkana") → {phase: 3, label: "Emergency"}
# Sub-agent 3: crop_calendar("maize", "lowland") → {plant: "Mar-Apr", yield: "15-25 bags/acre"}

The swarm doesn't need to browse. It calls tools. It gets structured data. It synthesizes 47 counties in parallel.

The 5 Swarm Use Cases, Mapped to East Africa MCPs

Kimi's documentation identifies 5 swarm archetypes. Each one maps directly to the coordination infrastructure stack.

1. Discovery at Scale → `county-mcp` + `wapimaji-mcp` + `soko-mcp`

Prompt pattern: "For each of N items, find [field 1, 2, 3]. Output as spreadsheet."

East Africa application: Spawn 47 sub-agents, one per Kenya county. Each agent calls county_information(), drought_phase_query(), and market_timing_guide(). Output: a priority matrix for infrastructure investment, structured, in parallel.

Previously this required a data analyst and 3 weeks. With the swarm + MCP layer: one prompt.

2. Output at Scale → `historia-mcp` + `habari-mcp` + `county-mcp`

Prompt pattern: "Produce a [N]-page [report] with full citations."

East Africa application: "Write a 50-page Kenya devolution impact report. For each of the 47 counties, synthesize budget allocation, service delivery gaps, and historical context." The swarm assigns sub-agents per county, each calling the MCP stack for structured data, and synthesizes the full report.

3. Perspective at Scale → `kra-mcp` + `haki-ya-kazi-mcp` + `faida-mcp`

Prompt pattern: "Review this plan from [role 1, 2, 3, 4] simultaneously."

East Africa application: "Evaluate this informal business proposal from the perspective of: KRA tax compliance officer, a labour rights advocate, an NSE investment analyst, and a SACCO loan officer." Each sub-agent uses its respective MCP tools and produces domain-specific concerns. Synthesis in one run.

4. Processing at Scale → `afya-mcp` + `familia-mcp` + `diaspora-mcp`

Prompt pattern: "For each of N inputs, do [task]. Output indexed by input."

East Africa application: "Process these 200 remittance scenarios. For each, determine: NHIF eligibility at home, applicable KRA withholding, and diaspora investment options." Each scenario calls three MCP servers. 200 scenarios in parallel.

5. Long-Horizon Execution → Full stack coordination

Prompt pattern: Deep, multi-phase build running 13+ hours.

East Africa application: "Over the next 8 hours, audit Kenya's digital public goods landscape, identify the top 10 gaps, research comparable solutions in comparable countries, and produce a 200-page strategic report with implementation recommendations." The swarm coordinates historia, habari, wapimaji, county, kilimo, afya — all the layers — across the full execution window.

The Competitive Positioning That Matters

The Kimi article says Claude Cowork is "one smart person at a desk who can open your folders." That's accurate for general use.

But the model shifts when MCP servers are domain-specific institutional knowledge APIs. That's a different category entirely.

The East Africa coordination stack is 30 MCP servers covering:

Economic (10): mpesa · mkopo · bima · soko · sifa · remit · kra · faida · familia · diaspora

Physical (4): wapimaji · nishati · usafiri · ardhi

Social (9): afya · afya-ya-akili · elimu · kazi · haki-ya-kazi · kilimo · jumuia · church · tafsiri

Civic (5): nyumba · habari · mazingira · county · historia

Foundation (2): civic-agent-kit · offline

Each one is a structured tool call. Each one gives agent swarms reliable, domain-specific information that general web search cannot.

When 300 Kimi agents show up in Nairobi, the tool layer is already ready.

The Offline Dimension

The Kimi article glosses over one assumption: reliable cloud connectivity.

The thesis document for East Africa infrastructure notes: "Never assume OpenAI survives. Never assume Anthropic stays accessible. Never assume export controls disappear."

That's why offline-mcp was the hardest layer to build but the most important. It wraps Ollama for local inference, runs on a Raspberry Pi on a 50W solar panel, and gives rural clinics, schools, and community offices AI capability without depending on any cloud provider.

300-agent cloud swarms are the ceiling. Local offline inference is the floor. The East Africa stack is built for both ends of that range.

The Practical Entry Point

# Try one MCP now — any MCP-compatible client (Claude, Cursor, LibreChat)
pip install mpesa-mcp          # M-PESA mobile payments
pip install wapimaji-mcp       # Drought and water access
pip install county-mcp         # Kenya 47 counties
pip install kilimo-mcp         # Precision agriculture
pip install familia-mcp        # Family law and inheritance

And the swarm prompt that will work once you have it:

Swarm task: Research all 47 Kenya counties. For each:
- Infrastructure coverage (water, health, education, energy)
- Current NDMA drought phase
- Top agricultural crop timing window for next 90 days
- CDF budget allocation

Output as a sortable spreadsheet with a final priority ranking by
(gap score × population). Export as Excel.

That's a 47-agent discovery swarm with structured MCP tool calls. One prompt. One file.

What Comes Next

The 5 swarm archetypes are a capability framework. The 30 MCP servers are a tool library.

The gap between "agent swarm that searches the web" and "agent swarm with domain APIs" is the same gap as the difference between a research assistant and a subject-matter expert. The MCP stack encodes the expertise. The swarm scales the execution.

Six months from now, this combination will be how policy analysts, development economists, county planners, and diaspora investors engage with East Africa's institutional data. Not one tab at a time.

The rails were built before the trains arrived.

Stack: 30 MCP servers · All MIT · All on PyPI · All Glama-listed

GitHub: github.com/gabrielmahia

Nairobi Stack: gabrielmahia.github.io/nairobi-stack

DEV Community: Gabriel Mahia

mpesa-mcp Just Joined the awesome-mcp-servers Directory — Here's What That Means

mpesa-mcp Just Joined the awesome-mcp-servers Directory

What it took

The Glama badge

Downloads

The 7-Server Stack: How East Africa's Coordination Infrastructure Works Together

The 7-Server Stack: How East Africa's Coordination Infrastructure Works Together

The theory

The stack

How they compound

What's next

Introducing kazi-mcp: Labor Market Coordination for Kenya's 15 Million Informal Workers

Introducing kazi-mcp: Labor Market Coordination for Kenya's 15 Million Informal Workers

What kazi-mcp does

Why labor coordination is a structural problem

The coordination infrastructure suite

Try it

Africa Is Not Behind. It's Building on Better Rails.

Africa Is Not Behind. It's Building on Better Rails.

What Alvin Toffler Would Say

What the Rails Look Like

The Multipolar Reality

Tanzania Is Next

The One Thing

Build Rails, Not Trains: A Framework for AI Infrastructure in the Global South

Build Rails, Not Trains: A Framework for AI Infrastructure in the Global South

The Rail vs. The Train

Diagnose Structural Absences

Build at Your Intersections

The Timing Layer

Stewardship, Not Ownership

The Decay Function

What the Stack Looks Like Now

Why 'Offline-First AI' Is No Longer Optional for the Global South

Why "Offline-First AI" Is No Longer Optional for the Global South

The infrastructure reality

What offline-first actually means

Why this matters beyond connectivity

The hardware reality

Integration with the broader stack

What to build next

31 MCP Servers for Africa — and Why the Rest of the World Should Care

31 MCP Servers for East Africa — and Why the Rest of the World Should Care

The Architecture Problem They Don't Teach You

What Each Layer Does

The Sovereignty Problem

The Parallels for Every Developer

Install and Try

kra-mcp: Kenya Revenue Authority Tax Compliance via MCP

PAYE, VAT, PIN registration — now accessible via AI agents

What MCP, A2A, and Google ADK Actually Unlock for African Coordination Infrastructure

The MCP problem

The A2A problem

The ADK problem

What this enables

faida-mcp: Kenya Capital Markets via AI Agents

NSE, Treasury Bonds, Unit Trusts, Diaspora Investment

The Loop That Creates Civilization Infrastructure

The Loop That Creates Civilization Infrastructure

Two Architecture Documents, One Stack

The Tri-Polar Model Router

The 7 Agent Types, Mapped

What "fomu-mcp" Does

The Real Moat

The Invariant That Matters Most

300 AI Agents Just Showed Up for East Africa. The Tool Layer Was Already Ready.

300 AI Agents Just Showed Up for East Africa. The Tool Layer Was Already Ready.

The Problem Agent Swarms Hit Without Domain APIs

The 5 Swarm Use Cases, Mapped to East Africa MCPs

1. Discovery at Scale → county-mcp + wapimaji-mcp + soko-mcp

2. Output at Scale → historia-mcp + habari-mcp + county-mcp

3. Perspective at Scale → kra-mcp + haki-ya-kazi-mcp + faida-mcp

4. Processing at Scale → afya-mcp + familia-mcp + diaspora-mcp

5. Long-Horizon Execution → Full stack coordination

The Competitive Positioning That Matters

The Offline Dimension

The Practical Entry Point

What Comes Next

1. Discovery at Scale → `county-mcp` + `wapimaji-mcp` + `soko-mcp`

2. Output at Scale → `historia-mcp` + `habari-mcp` + `county-mcp`

3. Perspective at Scale → `kra-mcp` + `haki-ya-kazi-mcp` + `faida-mcp`

4. Processing at Scale → `afya-mcp` + `familia-mcp` + `diaspora-mcp`