DEV Community: Gabriel Mahia

The Agricultural Data Africa Needs Already Exists. It's Just 100 Years Old.

Gabriel Mahia — Tue, 11 Aug 2026 10:00:00 +0000

The data problem for AI in African agriculture is not a lack of data.

It is a structural absence of structured data — the kind that AI agents can query, validate, and reason with.

The raw material exists. It has existed for over a century. It sits in the public domain, digitized by libraries and archives, waiting to be structured.

What the public domain contains

The British East Africa Protectorate agricultural reports from 1910-1922 document, county by county, which crops grew where, what yields looked like in drought years versus good years, which soil types supported what cultivation, and which traditional practices survived contact with colonial agricultural extension.

The Kew Gardens Economic Botany Series from 1906-1920 contains botanical surveys of East African crops — sorghum, millet, cassava, cowpea, moringa — with documented water requirements, storage characteristics, and soil tolerances.

The East Africa Meteorological Department records from 1900-1940 show rainfall patterns before the satellite era: where the long rains reliably arrive, where they don't, where the variability is structurally high.

These documents are free. They are in the public domain. They are not behind paywalls. They are in libraries.

The structural absence

The problem: they are in the format of 1910.

Scanned PDFs. Handwritten tables. Narrative reports in colonial English. Measurement systems that predated standardization.

No AI agent built in 2025 can query them the way it needs to. "What is the planting calendar for sorghum in semi-arid Kenya?" requires that someone has extracted, structured, validated, and made available the answer in a format that agents can use.

That structured layer is what's missing. Not the underlying knowledge.

What structured public domain data enables

The MCP servers in the East Africa coordination stack (wapimaji-mcp, kilimo-mcp, bima-mcp) need grounded knowledge to reason correctly.

When a farmer asks an AI agent about optimal planting dates for a semi-arid county, the agent needs historical knowledge of rainfall patterns and crop tolerances — not just a general LLM approximation.

That knowledge exists in the 1910 Kew surveys. The work is structuring it so the MCP can use it.

What was structured this week

Six public domain datasets now available on HuggingFace:

East Africa agricultural data — crop profiles, rainfall zones, soil types from USDA and Kew (1906-1922)
Swahili historical corpus — Krapf 1882, Taylor 1891, Steere 1870: the vocabulary of East African coordination in the language 200 million people speak
East Africa health historical — disease patterns, altitude factors, traditional medicine documentation (1895-1920)
East Africa legal and land tenure — customary systems, colonial legislation, dispute resolution (pre-1928)
Africa historical maps catalog — metadata for PD maps from Library of Congress, National Archives, Kew (1688-1925)
Open government climate catalog — NASA, NOAA, USDA datasets structured for African agricultural use

All public domain. All structured for AI agent use. All connected to the coordination infrastructure stack.

The knowledge infrastructure problem in Africa is not a lack of knowledge. It is a lack of structured access to knowledge that already exists.

Public domain works published before 1928 are the closest thing to free raw material in the information economy. The opportunity is not to extract value from them. It is to structure them so they can flow.

These datasets are available at huggingface.co/gmahia. Related coordination tools at pypi.org/user/gmahia.

Building Coordination Infrastructure: What 32 MCP Servers Without a Bus Look Like

Gabriel Mahia — Mon, 03 Aug 2026 10:00:00 +0000

Thirty-two MCP servers for Kenya's coordination domains.

Water. Health. Agriculture. Insurance. Land. Education. Transport. Tax. Labor. Market prices.

Each one works. None talks to any other.

This is what 32 isolated tools looks like in practice: a CHW in Kisumu flags a cholera cluster. The water quality system doesn't know. The county procurement system doesn't know. The emergency medicine supply chain doesn't know. The tools that need to respond are all present. The coordination between them doesn't exist.

The architectural problem

The Model Context Protocol ecosystem is growing fast. For most of the world, it's growing in domains that already have coordination infrastructure: calendar apps, email clients, project management tools. These tools coordinate with each other through years of API integrations, webhooks, Zapier connections, and shared data stores.

African coordination domains don't have that legacy. They're being built now, from scratch, on MCP.

That means the coordination layer has to be built at the same time.

What a coordination layer looks like at the MCP level

africa-coord-bus defines a CoordinationEvent — a standard cross-domain signal schema — and an EventBus that routes events to the tools that need to respond.

The routing table is explicit:

Trigger	Cascade
`water.drought_alert` (Warning+)	bima-mcp, kilimo-mcp, soko-mcp
`water.drought_alert` (Alert+)	+ afya-mcp, county-mcp
`health.disease_outbreak` (cholera)	wapimaji-mcp water quality check
`agriculture.price_spike` (>30%)	afya-mcp food security watch
`water.flood_alert`	afya-mcp waterborne watch, county-mcp

Custom rules take three lines:

from africa_coord_bus import RoutingRule, EventDomain, EventSeverity

bus.routing.add(RoutingRule(
    name="locust→emergency_procurement",
    trigger_domain=EventDomain.AGRICULTURE,
    trigger_event_type="locust_swarm",
    trigger_min_severity=EventSeverity.ALERT,
    target_actions=["fomu-mcp.emergency_procurement", "county-mcp.agriculture_alert"],
))

The composable coordination stack

The pattern that's emerging for East Africa:

Public domain datasets (HuggingFace)
        │ grounding knowledge
        ▼
32 MCP servers (PyPI) ←── africa-coord-bus
        │
        ▼
A2A + ADK agents
        │
        ▼
Streamlit coordination interfaces

Each layer is replaceable. The models are replaceable. The MCP servers are replaceable. What persists is the coordination architecture.

Install

pip install africa-coord-bus

Source: github.com/gabrielmahia/africa-coord-bus

The coordination gap was the last missing layer. It's now installable.

Source: africa-coord-bus on PyPI

MCP, A2A, and Google ADK for East Africa: What the Coordination Stack Looks Like

Gabriel Mahia — Fri, 31 Jul 2026 10:00:00 +0000

Three protocols landed in 2024 that change what AI agents can do in production: MCP (Model Context Protocol), A2A (Agent-to-Agent), and Google ADK (Agent Development Kit).

The question for Africa's coordination infrastructure is not whether these protocols are technically interesting. The question is: what does the absence of domain-specific implementations mean for the coordination problems — health, water, agriculture, land, education — that remain unsolved at scale?

The structural absence

Most MCP implementations connect to platforms that already exist in rich countries: Slack, Google Calendar, GitHub, Stripe, Salesforce. The ecosystems those tools coordinate are already coordinated. The problem is solved.

The structural absence is in the domains where coordination is genuinely broken:

A community health worker in Turkana County manages 1,200 households with a paper register. No MCP server for CHW coordination.
A smallholder farmer in Embu has no way to know today's market price at the Meru collection point before deciding to sell. No MCP server for farm-gate price information.
Drought early warning data exists (NASA NDVI, NOAA CHIRPS) but there is no structured AI-accessible interface to it. No MCP server for drought intelligence.

These are not technical problems. They are data structuring and interface design problems. The protocols exist. The domain implementations don't.

What the stack looks like

The East Africa coordination stack now includes 31 MCP servers:

Payments: M-Pesa API via Daraja (mpesa-mcp)
Water/drought: Satellite data integration (wapimaji-mcp)
Agriculture: Market coordination, crop advisory (kilimo-mcp, soko-mcp)
Parametric insurance: Satellite-triggered coverage (bima-mcp)
Health: County health service coordination (afya-mcp, county-mcp)
Land: Registry coordination (ardhi-mcp)
Tax compliance: Kenya Revenue Authority (kra-mcp)
Capital markets: NSE data access (faida-mcp)
Labor rights: Worker compliance (haki-ya-kazi-mcp)
Language: Swahili NLP infrastructure (swahili-civic-nlp, tafsiri-mcp)

The A2A pattern enables agents built on these servers to coordinate without bespoke integration code. The ADK pattern provides the framework for agents that can plan multi-step tasks — necessary for coordination workflows spanning multiple API calls and decisions.

The architecture gap this addresses

The composable model future assumes domain knowledge is accessible to AI agents through structured interfaces. For most African coordination domains, it is not.

The problem is not a model problem. GPT-4, Claude, and Gemini are accessible. The problem is that there is no structured interface between those models and the data that would make them useful for a CHW in Turkana, a farmer in Embu, or a water officer in Wajir.

MCP, A2A, and ADK are the protocol layer. The East Africa implementations are the domain layer. The work is connecting them.

All servers available at pypi.org/user/gmahia and indexed at Glama.

Build Your First East Africa MCP Server in 30 Minutes

Gabriel Mahia — Tue, 28 Jul 2026 10:00:00 +0000

Every tool in the East Africa coordination infrastructure stack started from the same scaffold. Here's exactly how to build and publish one yourself.

What You're Building

An MCP server is a Python package that exposes tools to AI assistants. When a user installs it and connects it to Claude, the AI can call your tools as naturally as answering a question.

pip install your-mcp-server
# Then Claude can:
# "Check NHIF coverage for outpatient surgery" → calls your tool → returns structured result

Step 1: Set Up the Project (2 min)

your-mcp-server/
├── src/
│   └── your_package/
│       ├── __init__.py
│       └── main.py
├── pyproject.toml
├── README.md
└── .github/
    └── workflows/
        └── publish.yml

mkdir your-mcp-server && cd your-mcp-server
mkdir -p src/your_package
touch src/your_package/__init__.py src/your_package/main.py

Step 2: Write Your Tool (10 min)

# src/your_package/main.py
from __future__ import annotations
from typing import Annotated
from fastmcp import FastMCP

mcp = FastMCP(
    name="your-mcp-server",
    instructions="Describe what your server does in one paragraph.",
)

@mcp.tool(
    description=(
        "What this tool does in plain language. "
        "Include the Western parallel if applicable. "
        "Note if it uses DEMO data."
    )
)
def your_tool(
    param1: Annotated[str, "Description of param1"],
    param2: Annotated[int, "Description of param2"] = 0,
) -> dict:
    # Your logic here
    return {
        "result": f"Processed {param1}",
        "note": "DEMO — replace with real data source in production",
        "source": "your-mcp-server",
    }

def main():
    mcp.run()

if __name__ == "__main__":
    main()

Step 3: Configure pyproject.toml (3 min)

[build-system]
requires = ["setuptools>=61.0"]
build-backend = "setuptools.build_meta"  # ← exact string, no variation

[project]
name = "your-mcp-server"
version = "0.1.0"
description = "One-line description"
authors = [{name = "Your Name", email = "you@example.com"}]
license = {text = "MIT"}
readme = "README.md"
requires-python = ">=3.9"
dependencies = ["fastmcp>=2.0.0"]

[project.scripts]
your-mcp-server = "your_package.main:main"  # CLI entry point

[tool.setuptools.packages.find]
where = ["src"]  # ← required for src/ layout

Common mistake: build-backend = "setuptools.backends.legacy:build" is not valid. Use exactly "setuptools.build_meta". This error causes python -m build to fail silently in CI.

Step 4: Set Up CI Publishing (5 min)

Option A: API Token (faster)

Create a PyPI API token at pypi.org/manage/account/#api-tokens
Add as PYPI_API_TOKEN in your GitHub repo → Settings → Secrets

Option B: OIDC Trusted Publisher (more secure, recommended)

Create the package on PyPI first (one push via token)
Go to pypi.org/manage/project/{name}/settings/publishing/
Add GitHub Actions publisher: owner, repo, publish.yml, environment pypi

.github/workflows/publish.yml:

name: Publish to PyPI
on:
  push:
    tags: ["v*"]
jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with: {python-version: "3.11"}
      - run: pip install build
      - run: python -m build
      - uses: pypa/gh-action-pypi-publish@release/v1
        with:
          password: ${{ secrets.PYPI_API_TOKEN }}

Step 5: Publish (2 min)

git init && git add . && git commit -m "initial commit"
git remote add origin https://github.com/yourusername/your-mcp-server
git push -u origin main

git tag v0.1.0 && git push origin v0.1.0
# → GitHub Actions runs → pip install your-mcp-server works in 2-3 minutes

Step 6: Connect to Claude (1 min)

# Install
pip install your-mcp-server

# Add to Claude Code
claude mcp add myserver -- your-mcp-server

# Test
claude "Use myserver to process X"

East Africa Design Patterns

A few patterns specific to building for this context:

Trust integrity:

return {
    "result": result,
    "note": "DEMO — Synthetic data for educational purposes. Not operational guidance.",
    "source": "your-mcp-server. Research basis: [cite your source]",
}

Swahili/English bilingual errors:

except Exception as e:
    return {"error": f"Hitilafu / Error: {str(e)[:60]}. Jaribu tena / Try again."}

Version bump workflow:

# Edit pyproject.toml → version = "0.2.0"
git commit -am "bump: v0.2.0"
git tag v0.2.0 && git push origin main --tags

That's the complete cycle. Every MCP server in the East Africa coordination stack was built and published with exactly this scaffold.

Full portfolio and all 12 packages: gabrielmahia.github.io

Constitutional Rights in Swahili: Building a Multi-Agent Debate System

Gabriel Mahia — Sat, 25 Jul 2026 10:00:00 +0000

40%+ of Kenyans don't know their constitutional rights. Not because the rights don't exist — Kenya's 2010 constitution is among the most progressive in Africa — but because the information is locked in dense legal language, available only in English, and not easily accessible through any institutional channel.

hakiyangu (haki = rights, yangu = mine — "my rights") is a multi-agent constitutional debate system that presents both the government's position and the citizen's rights on any constitutional question, in Swahili or English.

The Research Basis

arXiv:2305.19118 — Liang et al. (2023): "Encouraging Divergent Thinking in Large Language Models through Debate"

This paper demonstrated that when multiple AI agents argue opposing positions on a question, the final synthesized answer is measurably less biased and more accurate than a single-agent response. The adversarial format forces the AI to consider the strongest version of each position before synthesizing.

For constitutional rights questions, this is particularly important: the government has legitimate interests, and citizens have constitutional protections. Neither perspective alone gives a complete picture.

The Three-Agent Architecture

# Agent 1: Government Legal Officer
gov_response = call_gemini(
    system="You are a Senior Government Legal Officer defending the Kenya government 
            position on constitutional rights. Be factual. Cite actual articles.",
    user=f"Citizen question: '{question}'"
)

# Agent 2: Human Rights Advocate  
cit_response = call_gemini(
    system="You are a Human Rights Advocate defending citizen constitutional rights.
            Cite actual articles. Acknowledge government has valid interests.",
    user=f"Citizen question: '{question}'"
)

# Agent 3: Constitutional Law Lecturer (synthesis)
synthesis = call_gemini(
    system="You are an independent Constitutional Law Lecturer at University of Nairobi.
            Synthesize both sides. Focus on: what can the citizen do, what are their 
            strongest legal protections, when to seek formal legal help.",
    user=f"Government argued: {gov_response[:300]}
Rights advocate argued: {cit_response[:300]}"
)

Each agent has a defined role and is explicitly instructed to cite the actual Kenya Constitution articles, not summarize them.

Rights Covered

Six rights from the Kenya Constitution 2010:

Freedom of Expression (Article 33)
Right to Property (Article 40)
Right to a Fair Trial (Article 50)
Freedom from Discrimination (Article 27)
Right to Education (Article 43)
Freedom of Movement (Article 26)

Each right has pre-loaded context, the government's constitutional basis for limitations, and the citizen's strongest protections.

The Error Handling Lesson

The original haki-debate-ai (now hakiyangu) had no try/except around the three Gemini calls. When the API returned HTTP 404 (due to a v1beta vs v1 endpoint change), the error surfaced as a full Streamlit traceback — including file paths and code snippets.

# Before: one unprotected call, full crash on error
gov_response = call_gemini(gov_system, question)

# After: wrapped calls with Swahili error messages
try:
    gov_response = call_gemini(gov_system, question)
except Exception as e:
    gov_response = f"⚠️ Hitilafu: {str(e)[:60]}"

Users see "Hitilafu ya API (404). Jaribu tena baadaye. / API error. Please try again later." — not a Python traceback. Production apps owe users graceful degradation.

Deploy It

# Streamlit Cloud: github.com/gabrielmahia/hakiyangu
# Secret: GOOGLE_API_KEY = "your-gemini-key"

Try it at hakiyangu.streamlit.app (setup in progress)

github.com/gabrielmahia/hakiyangu · CC BY-NC-ND 4.0

The 500x Data Gap: Why AI Makes 4x More Errors in Swahili Than English

Gabriel Mahia — Wed, 22 Jul 2026 10:00:00 +0000

There's a paper you need to read if you're building AI for African languages: arXiv:2509.04516.

Its finding: AI models produce approximately 4 times more errors in Swahili than in English. The root cause isn't model architecture. It's training data. Swahili has approximately 500 times less representation in Common Crawl (the primary web data source for most LLMs) than English.

500x less data → 4x more errors → every Swahili-language AI product is starting from a significant accuracy deficit.

Why This Window Is Closing

This is the part that urgency-frameworks often get wrong. It's not "act now because the problem is bad." It's act now because the window for establishing data primacy is narrowing.

AI development has entered a self-improving phase. Anthropic's internal research (May 2026) documents that 80%+ of merged code at major AI labs is now AI-authored, with engineers deploying 8x more code per day than two years prior. This trajectory compounds.

Whatever language advantages exist today will be amplified by self-improvement. Swahili data that enters the training pipeline this year compounds forward. Data that enters in 2028 competes with a much more entrenched English-language advantage.

The window for establishing Swahili data primacy is 12–18 months. Not years.

What We've Built

Four Swahili NLP datasets, all CC BY 4.0, all on HuggingFace:

swahili-civic-nlp

Annotated sentences covering government services, constitutional rights, M-PESA financial terms, county administration. Ground truth for civic AI agents that need to understand Swahili queries about rights and services.

kenya-agricultural-qa

Q&A pairs covering crop disease (MSV, FAW), market prices, planting calendars, livestock health. Grounded in KALRO/KEPHIS data. For AI advisors that need to answer farming questions accurately in Swahili.

kenya-legal-nlp

Annotated Kenya legal documents — Constitution, Employment Act, Land Act — with NER labels (PERSON, ORG, LAW, DATE) and QA pairs. For legal information retrieval in Swahili.

kenya-civic-data

County government data, budget allocations, public service metrics. Structured for relation extraction and question answering on civic content.

The LINGUA Africa Application

The LINGUA Africa grant (Masakhane × Microsoft × Gates Foundation) funds exactly this gap: Swahili-native AI infrastructure for East African financial inclusion, civic accountability, and education.

The proposed deliverables:

4 additional Swahili datasets (financial Q&A, health corpus v2, agricultural Q&A v2, civic NLP v2) — 95,000+ annotated examples
Fine-tuned model evaluated on IrokoBench (arXiv:2406.03368), the African language benchmark
Voice-native Swahili agent using GPT-Realtime-Whisper

Submitted June 2026.

How You Can Help

Every Swahili developer, linguist, or domain expert who contributes to this dataset pool helps close the gap. The datasets are CC BY 4.0 — use them, extend them, cite them.

If you have access to Swahili domain-specific text (agricultural extension materials, court transcripts, medical protocols, government forms), reach out: contact@aikungfu.dev.

The 200 million Swahili speakers of East Africa deserve AI that works as well for them as it does for English speakers. That outcome requires intentional data work, now.

HuggingFace datasets: gmahia

3,000 Patients Per Worker: Can AI Support Kenya's Community Health Workers?

Gabriel Mahia — Sun, 19 Jul 2026 10:00:00 +0000

Kenya has approximately 100,000 Community Health Workers (CHWs — locally called Community Health Extension Workers, or CHEWs). They cover a population of 54 million. That's roughly one CHW per 540 people, but in rural areas the ratio reaches 3,000:1.

These workers are the first and often only medical contact for millions of Kenyans. They do triage. They decide who needs a hospital referral. They counsel on pregnancy, malnutrition, fever, diarrhoea. They work from memory and a printed protocol card.

afyanipoa (afya nzuri = good health in Swahili, "poa" = cool) is an AI clinical co-pilot for these workers.

The Research Basis

arXiv:2408.17216 — "Democratizing AI in Africa: Federated Learning for Low-Resource Edge Devices" (2024)

This paper demonstrated that federated learning can be deployed on Raspberry Pi-class devices (the computing tier of affordable Android phones) in 5 African countries simultaneously, achieving acceptable model accuracy without centralized data collection. The implication: clinical AI doesn't require cloud connectivity.

WHO Community Health Workers Reference Group (2022): The WHO documents that CHW programs are most effective when workers have access to real-time decision support — but most programs only provide printed job aids updated annually.

Kenya MOH CHEW Curriculum: The Kenya Ministry of Health publishes the official training curriculum for CHEWs. The integrated management protocols for fever, cough, diarrhoea, ANC, and malnutrition are well-defined and systematizable.

What afyanipoa Does

The app has three layers:

1. Protocol library (always available, no AI needed)

Embedded Kenya MOH protocols for 8 conditions: fever, cough, diarrhoea, malnutrition, ANC, family planning, mental health, TB screening. Danger signs, referral triggers, dosing by age/weight. Zero API calls required.

2. AI clinical guidance (when API key is configured)

A CHW describes a patient's complaint in Swahili. The AI synthesizes the relevant protocol sections with the specific presentation and returns:

ISHARA ZA HATARI / DANGER SIGNS (check first)
TATHMINI / ASSESSMENT (what to examine)
MATIBABU / IMMEDIATE ACTION
PELEKA / REFERRAL (when, where, why)
FUATILIA / FOLLOW-UP

3. Emergency contacts (always visible)

0800 720 571 (Kenya health emergency line), county referral hospital numbers, maternal emergency contacts.

The Safety Architecture

This is safety-critical software. The design decisions reflect that:

DEMO label: visible on every screen
AI output: labeled "decision support, not diagnosis"
Danger signs: displayed FIRST, before any AI output
Referral bias: when in doubt, the prompt leans toward referral
Emergency contacts: persistent, not hidden in menus

The Gemini prompt explicitly instructs the model:

"When in doubt between management at home and referral, recommend referral. A missed referral in the field has worse consequences than an unnecessary one. This is decision SUPPORT — the CHW makes the final call."

The Endpoint Fix

One lesson from this deployment: always use the stable /v1/ endpoint, not /v1beta/.

# Wrong — returns 404 for gemini-2.0-flash
url = f"generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent"

# Right — try v1 first, fall back to v1beta
for ver in ("v1", "v1beta"):
    url = f"generativelanguage.googleapis.com/{ver}/models/gemini-2.0-flash:generateContent"
    try:
        # ... call ...
        return result
    except HTTPError as e:
        if ver == "v1beta": raise
        continue

This pattern has since been applied to all Gemini-enabled apps in this portfolio.

Deploy It Today

# Streamlit Cloud — free tier
# Repo: github.com/gabrielmahia/afyanipoa
# Secret: GOOGLE_API_KEY = "your-gemini-key"

Get a free Gemini API key at console.cloud.google.com → Gemini API → Enable → Create key.

github.com/gabrielmahia/afyanipoa · CC BY-NC-ND 4.0

Reputation Portability: The Missing Infrastructure for Economic Mobility

Gabriel Mahia — Thu, 16 Jul 2026 10:00:00 +0000

A skilled plumber in Chicago can move to Los Angeles and immediately find work. Her Yelp reviews, contractor license, and Angie's List history travel with her. Strangers trust her before she's done a single job.

A skilled mason in Mombasa cannot take her reputation to Nairobi. Trust is tribal and local. Hiring defaults to personal networks. The most talented people outside existing networks are invisible.

This is not a cultural problem. It's an infrastructure problem.

What Reputation Portability Infrastructure Looks Like

In mature economies, the infrastructure exists in fragments:

Uber/Lyft: Star ratings that follow a driver across cities
LinkedIn: Endorsements and work history that cross borders
BBB (Better Business Bureau): Verified complaint and resolution history
Angie's List / Thumbtack: Job completion ratings for home services
Upwork JSS: Job Success Score based on completed contracts
Professional licensing boards: Verifiable credentials (doctor, electrician, contractor)

Each of these solves the same problem: how do you compress trust between strangers at scale?

sifa-mcp (Sifa = reputation/praise in Swahili) is a portable reputation MCP server that implements this infrastructure for East Africa's informal economy.

The Trust Score Architecture

from sifa_mcp import create_worker_profile, add_service_record, get_reputation_profile

# Create a portable profile
profile = create_worker_profile(
    full_name="Amina Odhiambo",
    phone="0712345678",
    primary_skill="construction",
    sub_skills="masonry,tiling,plastering",
    location="Mombasa",
    years_experience=8
)
# → profile_id: "SFA-A3F2B19C4E1D"

# Add a completed job
add_service_record(
    profile_id="SFA-A3F2B19C4E1D",
    client_name="ABC Contractors",
    client_phone="0722000000",
    service_type="Kitchen tiling",
    duration_days=5,
    payment_kes=15000,
    client_rating=5
)

# Check trust for a new employer
profile_data = get_reputation_profile(
    profile_id="SFA-A3F2B19C4E1D",
    requester_context="employer"
)
# → trust_tier: "ESTABLISHED"
# → recommendation: "Good track record. Suitable for most engagements."

The Score Decomposition

The trust score (0–100) is built from four signals:

Signal	Max Points	Rationale
Job volume	30	Demonstrates activity, not just registration
Average quality	35	Client-rated — heaviest weight
Verified records	20	Client OTP confirmation prevents fabrication
Tenure	15	Long history = stability signal

This maps directly to how humans assess trust: frequency + quality + verification + history.

The Production Path

sifa-mcp is DEMO infrastructure. The in-memory profile store needs to be backed by a persistent database. More critically, production requires identity verification tied to Kenya's Huduma Number / NIIMS system — to prevent workers from fabricating verified records.

The regulatory and identity infrastructure for this exists in Kenya. The coordination layer (portable reputation MCP) does not. That's the gap sifa-mcp fills — and the conversation it starts.

Why NITA Alignment Matters

The skill categories in sifa-mcp are aligned with Kenya's National Industrial Training Authority trade classifications. This isn't accidental — NITA certification is the existing institutional trust anchor for skilled tradespeople. A sifa-mcp score that references NITA-certified training becomes part of a verifiable credential chain.

pip install sifa-mcp

github.com/gabrielmahia/sifa-mcp · MIT License

Parametric Insurance: When Satellite Data Replaces the Claims Adjuster

Gabriel Mahia — Mon, 13 Jul 2026 10:00:00 +0000

Traditional crop insurance requires a claims adjuster to visit a farm, document damage, and approve a payout. In Kenya, where farms average 1.5 hectares and are scattered across 47 counties, this is economically impossible to do at scale.

The result: 2.3% insurance penetration. One bad drought = financial ruin.

Parametric insurance solves this by replacing the claims adjuster with satellite data.

How Parametric Insurance Works

Instead of insuring against "crop loss" (which requires verification), parametric insurance insures against a trigger event — a measurable proxy for loss:

Rainfall below 60mm in a 30-day growing period → automatic payout
NDVI (normalized difference vegetation index) below 0.3 in July → payout
Temperature above 38°C for 5+ consecutive days → payout

No claims process. No adjuster. If the satellite says the trigger fired, the payout happens automatically — within 72 hours, direct to M-PESA.

The Research Basis

ACRE Africa (2023): ACRE (Agriculture and Climate Risk Enterprise) has facilitated over $200M in parametric insurance across 12 African countries. Their methodology uses NDMA (National Drought Management Authority) data as the primary trigger source for Kenya.

NDMA Kenya: The NDMA publishes monthly county drought monitoring reports with rainfall deficit data, NDVI scores, and livestock condition indices. This is the data layer that makes parametric insurance possible.

IRI (International Research Institute for Climate and Society): El Niño/La Niña forecasting with 3-month lead time has been validated as a viable basis for planting-season insurance triggers in East Africa.

bima-mcp Implementation

from bima_mcp import parametric_risk_score

result = parametric_risk_score(
    county="Nakuru",
    crop="maize",
    season="long_rains",
    coverage_kes=50000
)
# → risk_tier: "MEDIUM",
# → trigger_threshold: "rainfall < 65mm in March-May growing period",
# → recommended_premium_kes: 3750,
# → payout_probability: 0.28,
# → data_source: "DEMO — modeled on NDMA county reports"

The Community Pool Tool

One of the more interesting tools is community_pool_calculator, which models informal risk-sharing:

from bima_mcp import community_pool_calculator

result = community_pool_calculator(
    group_size=25,
    avg_farm_value_kes=120000,
    target_coverage_pct=0.6,
    drought_probability=0.25
)
# → pool_size_needed_kes: 450000,
# → monthly_contribution_kes: 1500,
# → confidence_interval: "90% probability of full coverage for any single member in any given year"

Chama groups (informal savings societies) are already the primary financial institution for millions of Kenyan women. Parametric pooling maps directly to existing behavior.

What bima-mcp Covers

6 tools:

nhif_coverage_query — NHIF benefit lookup by category
parametric_risk_score — NDMA-based crop risk scoring
microinsurance_comparison — product comparison across providers
community_pool_calculator — informal risk-sharing models
claim_eligibility — trigger-based eligibility check
insurance_gap_analysis — what's uninsured in a given county

pip install bima-mcp

github.com/gabrielmahia/bima-mcp · MIT License

The Information Asymmetry That Costs East African Farmers Billions

Gabriel Mahia — Fri, 10 Jul 2026 10:00:00 +0000

A trader drives from Nairobi to Nakuru on Monday morning. Before leaving, he checks wholesale prices at Wakulima Market. He knows maize is 12% higher in Nairobi this week than last.

The farmer he buys from doesn't know this.

That information gap is not accidental. It's structural, persistent, and extractable by anyone with market access. The World Bank estimated in 2016 that price information asymmetries account for 10–15% of post-harvest losses in Sub-Saharan Africa. For Kenya's 8M+ smallholder farmers, that's billions in foregone income annually.

soko-mcp is a commodity price intelligence MCP server that begins to close this gap.

The Research Basis

Suri & Jack (2016): M-PESA adoption in Kenya lifted 194,000 households out of poverty, disproportionately women — primarily through improved market access and ability to store value. The mechanism: reduced friction in market participation.

World Bank "ICT and Agricultural Markets" (2016): In markets where farmers received SMS price updates, they achieved 8–10% higher farm-gate prices by timing sales or traveling to better markets.

EAGC East Africa Regional Market Monitor: The East Africa Grain Council publishes weekly price data for 12 commodities across 8 countries. This data exists. It's just not integrated into tools farmers actually use.

The Sell/Hold Problem

The core decision a farmer faces post-harvest:

"Should I sell my 50 bags of maize now, or store them for 2 months?"

This requires three inputs:

Current market price vs. historical average
Expected price trajectory (seasonal pattern)
Cost of storage (per bag per month)

from soko_mcp import sell_hold_decision

result = sell_hold_decision(
    commodity="maize",
    market="nakuru",
    quantity_bags=50,
    storage_cost_per_month_kes=500,
    months_can_store=3
)
# → recommendation: "HOLD 2 MONTHS"
# → expected_gain_kes: 8500 (net of storage costs)
# → confidence: "MODERATE"
# → caveat: "DEMO — based on synthetic seasonal patterns"

What the Model Does

The price model uses three signals:

Seasonal index: Maize prices in Kenya follow a predictable post-harvest depression (March–May) and pre-harvest premium (October–December). This is well-documented in EAGC data.
Regional spread: Nairobi-Nakuru price differentials average 12–18% depending on road conditions and fuel costs. A farmer 200km from Nairobi can calculate whether the transport cost is worth it.
Storage break-even: At KES 500/bag/month, a 15% price increase over 2 months yields KES 7,500 net gain on 50 bags. If expected increase is 8%, don't store — sell now.

Trust Integrity Note

All price data in soko-mcp is DEMO — synthetic data modeled on EAGC seasonal patterns. It does not connect to live market feeds.

Production integration requires:

EAGC API subscription (available to NGOs and research institutions)
NAFIS (National Agriculture and Food Information System) real-time feeds
Kenya National Bureau of Statistics retail price data

The model architecture is production-ready. The data connections are the next step.

Five Tools

pip install soko-mcp

commodity_price_query — current price + 30-day trend
regional_price_comparison — prices across 8 East Africa markets
price_trend_analysis — 12-month historical pattern
sell_hold_decision — net-of-storage recommendation
market_overview — full commodity dashboard

github.com/gabrielmahia/soko-mcp · MIT License

Building parametric crop insurance with wapimaji-mcp and bima-mcp

Gabriel Mahia — Mon, 06 Jul 2026 12:00:00 +0000

Building Parametric Crop Insurance with wapimaji-mcp and bima-mcp

Traditional crop insurance in Kenya requires an adjuster to visit the farm, assess the damage, file a claim, wait for processing, and — maybe — receive a payout months after the harvest has already failed.

Parametric insurance replaces the adjuster with satellite data. If drought reaches Phase 3 in your county, the policy pays out automatically. No adjuster. No waiting. No dispute.

Here's how to build a basic parametric insurance agent using two MCP servers.

The tools

wapimaji-mcp provides Kenya NDMA drought phase classifications across all 47 counties:

# Tool: kenya_county_drought
# Input: county_name
# Output: current drought phase (1-5), affected population, area

bima-mcp provides parametric risk scoring and insurance product matching:

# Tool: parametric_crop_risk
# Input: county, crop_type, area_ha, coverage_amount
# Output: risk score, premium estimate, trigger conditions

The agent workflow

User: "I have 2 hectares of maize in Turkana County. How much will crop insurance cost?"

Agent:
1. wapimaji_mcp.kenya_county_drought(county="Turkana")
   → Phase 4 (Emergency), 67% area affected

2. bima_mcp.parametric_crop_risk(
     county="Turkana", 
     crop_type="maize",
     area_ha=2,
     coverage_amount=50000
   )
   → Risk score: HIGH
   → Estimated premium: KES 4,200/season
   → Trigger: Phase 3+ for 3+ consecutive weeks
   → Payout timeline: 14 days after trigger

Why the combination works

Neither tool alone answers the question. The drought data provides current conditions; the risk tool prices the forward-looking exposure. Together, they give a complete picture in a single agent session.

The farmer gets: a current drought assessment, a premium quote, and the exact trigger conditions — without calling a broker, visiting an office, or waiting for a human intermediary.

This is the practical argument for coordination infrastructure. The data exists. The tools exist. The value comes from connecting them.

Demo data disclaimer

Both tools use synthetic demo data. In production, these would connect to real NDMA APIs and accredited insurance product APIs. The architecture is production-ready; the data sources need to be swapped.

Source code:

Building an Alternative Credit Score from M-PESA Behavioral Data

Gabriel Mahia — Fri, 03 Jul 2026 10:00:00 +0000

FICO was invented in 1956 and took five decades of credit card data to become the global standard. That data simply doesn't exist for most Kenyan adults. But something else does: M-PESA.

35 million Kenyans use M-PESA. Every paybill payment, every savings deposit, every Fuliza loan — that's a behavioral financial record. The question mkopo-mcp asks is: can you build a 300–850 credit score from it?

The Research Basis

The core insight comes from two bodies of work:

Breza & Kinnan (2021): Mobile money adoption in India measurably improved credit access for previously unbanked households. Transaction regularity was a stronger predictor of repayment than income level.

World Bank Financial Inclusion Database (2022): In Sub-Saharan Africa, 57% of adults who use mobile money have never had a formal bank account. That's the population FICO was never designed to serve.

Central Bank of Kenya Prudential Guidelines (2022): CRBs in Kenya are required to report both positive and negative credit information. Fuliza (M-PESA overdraft) data is already flowing to TransUnion Kenya.

The Score Model

from mkopo_mcp import alternative_credit_score

result = alternative_credit_score(
    monthly_income_kes=45000,
    mpesa_transactions_monthly=28,
    avg_transaction_kes=1850,
    paybill_payments_monthly=4,
    fuliza_usage="occasional",
    savings_behavior="regular_deposits",
    phone_tenure_years=3.5,
    months_of_history=18
)
# → score: 647, tier: "FAIR", loan_capacity_kes: 85000

The score is decomposed into four signals:

Signal	Weight	Proxy For
Income regularity	30%	Capacity
Payment consistency	25%	Willingness
Savings behavior	25%	Financial discipline
Tenure + history	20%	Stability

Why Behavioral Signals Work

The intuition: a person who pays their Nairobi Water paybill on time, every month, for 18 months is demonstrating financial discipline that's directly relevant to loan repayment. It's not income — it's behavior.

This is structurally similar to how FICO evolved to include rent payment data (FICO 10T, 2020) and how Experian Boost works in the US — both extend credit scoring to non-traditional signals.

The difference is that in Kenya, those signals are already flowing through one system (M-PESA), not scattered across utilities and landlords.

What mkopo-mcp Doesn't Do

Trust integrity matters here: mkopo-mcp is DEMO infrastructure. It does not connect to real M-PESA transaction data. It models how a score would be computed if such data were available.

Production deployment requires:

User consent for M-PESA transaction access (Safaricom API)
CBK data protection compliance (Data Protection Act 2019)
CRB registration for institutions submitting scores
Actuary-validated model weights (these are illustrative)

The infrastructure exists. The regulatory and data access path is defined. mkopo-mcp demonstrates the model.

The Impact Calculation

If even 10% of Kenya's 30M credit-invisible adults could access microfinance products through alternative scoring:

3M people with access to KES 50,000–200,000 productive loans
At 2% monthly default rate (optimistic) → marginal NPL is manageable
Kenya's MSME financing gap: approximately KES 1.1T (IFC, 2022)

That's not an app. That's coordination infrastructure.

pip install mkopo-mcp

github.com/gabrielmahia/mkopo-mcp · MIT License