Available for hire

Isaac Kyalo

Full-Stack Engineer · AI Integration & Microservices

5+ years building full-stack applications and distributed systems — decoupled frontends, microservices backends, event-driven pipelines, and AI integration layers. Open to remote opportunities.

Get Resume

device_service.py● running

 1# FastAPI service with RabbitMQ + MCP agent
 2from fastapi import FastAPI
 3from rabbitmq_easy import RabbitMQClient
 4from langchain_mcp_adapters.client import MultiServerMCPClient
 5from langchain.agents import create_react_agent
 6from langchain_openai import ChatOpenAI
 7
 8app = FastAPI()
 9mq = RabbitMQClient(host="rabbitmq")
10
11# MCP-connected AI agent
12async def build_agent():
13    async with MultiServerMCPClient({
14        "onfon": {
15            "url": "http://mcp-server:8001/sse",
16            "transport": "sse",
17        }
18    }) as client:
19        llm = ChatOpenAI(model="gpt-4o", temperature=0)
20        tools = client.get_tools()
21        return create_react_agent(llm, tools)
22
23@app.post("/devices/{device_id}/command")
24async def send_command(device_id: str, cmd: dict):
25    # publish to device queue
26    await mq.publish(
27        queue=f"device.{device_id}",
28        message={"cmd": cmd, "ts": utcnow()}
29    )
30    return {"status": "queued", "device": device_id}
31
32@app.get("/health")
33async def health():
34    return {"status": "ok", "broker": await mq.ping()}

Years Experience

30+

Projects Delivered

Open Source Packages

About me

Full-Stack Engineer · AI Integration Specialist

I build complete products — decoupled frontends, microservices backends, and AI integration layers wired into real production systems.

Full-stack engineer with 5+ years building production applications end-to-end — React and Next.js frontends, FastAPI, Django, Flask, Express, and Node.js backends in Python and TypeScript, and distributed systems that keep services decoupled and independently scalable. I have shipped many projects across fintech, IoT, analytics, and e-commerce.

On the AI side, my focus is integration and architecture — not training models but wiring LLMs, agents, and tools into real systems using LangChain, MCP (Model Context Protocol), RAG pipelines, and OpenAI / Anthropic APIs. I build the infrastructure that makes AI features reliable in production.

For async systems I use RabbitMQ and Kafka. For observability: Grafana, Prometheus, and Superset. Infrastructure lives in Docker, Kubernetes, and AWS. I have published two open-source Python packages on PyPI that solve real problems in microservice deployments.

Full-Stack Apps

React · Next.js · Django · Express

AI Integration

LangChain · MCP · RAG

Microservices

Docker · RabbitMQ · Kafka

Observability

Grafana · Prometheus · Superset

Full-Stack Application DevelopmentNext.js, FastAPI, Node.js

Distributed Systems & MicroservicesRabbitMQ, Kafka, decoupled arch

AI Integration & Agent ArchitectureLangChain, MCP, RAG — not model training

DevOps & ObservabilityDocker, Grafana, Prometheus

Database DesignPostgreSQL, Redis, Vector DBs

Model Deployment / RLHFActive learning area

LocationNairobi, Kenya (Open to Remote)

CurrentlyFull-Stack / AI Integration Engineer

EducationB.Sc. Information Technology, Kenyatta University

Contactisadechair019@gmail.com

Technical skills

Full-Stack AI & Systems Engineering

The tools and technologies I use on real projects — backend, AI/LLM, infrastructure, messaging, and observability.

AI / LLM Engineering

LangChainOpenAI APIAnthropic ClaudeMCP (Model Context Protocol)RAG PipelinesAI AgentsRLHF / Model DeploymentPrompt EngineeringEmbeddingsVector Search

MLOps & AI Infrastructure

MLflowHugging FacePineconeChromaDBModel VersioningInference OptimizationFeature EngineeringAWS SageMaker

Backend Development

PythonTypeScriptFastAPIDjangoFlaskNode.jsExpressREST APIsWebSocketsOAuth2JWTMicroservices

DevOps & Cloud

AWS (EC2 · S3 · RDS · Lambda)GCPDockerKubernetesDocker SwarmJenkinsGitHub ActionsNginxCI/CDBlue-Green Deploy

Databases & Caching

PostgreSQLMySQLMongoDBRedisInfluxDBConnection PoolingQuery OptimizationRaw SQLVector Databases

Async & Messaging

RabbitMQApache KafkaCeleryEvent-Driven ArchitecturePub/SubDead-Letter QueuesMessage BrokersAsync Processing

Data & Observability

GrafanaPrometheusApache SupersetInfluxDBMetrics & AlertingLog AggregationDashboardsData Visualization

What I've built

Systems Architecture Showcases

Production systems I've designed and engineered — illustrated with real technical depth, metrics, and architecture flows.

AI-Powered Data Analytics Engine

LLM-integrated queriesRAG over proprietary dataSemantic search API

Integrated LLM APIs (OpenAI + Anthropic) into an analytics platform to enable natural language querying over proprietary datasets. Built RAG pipelines with LangChain and Pinecone for semantic search, wired AI outputs into existing REST APIs, and set up the inference infrastructure to keep it reliable in production.

LangChainPineconeOpenAI APIAnthropic APIFastAPIPythonMLflow

// architecture flow

Client / Dashboard

↓

FastAPI REST Layer

↓

LangChain + RAG

↓

Pinecone VectorDB

↓

OpenAI / Anthropic API

↓

Response to Client

IoT Device Control Platform

Multi-partner device fleetZero-downtime deploysSub-100ms response

Distributed platform managing a large fleet of connected mobile devices across multiple partner networks. Built decoupled microservices with Redis caching to reduce DB load, RabbitMQ for guaranteed message delivery, and Docker Swarm blue-green deployments for zero-downtime releases. Monitored with Grafana and Prometheus dashboards.

FastAPIFlaskRedisRabbitMQPostgreSQLDocker SwarmGrafanaPrometheusJenkins

// architecture flow

Connected Devices

↓

FastAPI Gateway

↓

Redis Cache

↓

RabbitMQ Broker

↓

Worker Microservices

↓

PostgreSQL Cluster

↓

Grafana + Prometheus

Fintech Payment API Infrastructure

End-to-end encryptedEvent-driven processingOWASP compliant

Secure, OWASP-compliant payment processing backend with end-to-end encryption, real-time transaction monitoring, and event-driven fraud detection. Decoupled into independent services communicating via async queues with comprehensive audit trails and zero shared state between services.

FastAPIPostgreSQLRedisCeleryDockerAWSGitHub Actions

// architecture flow

Client Applications

↓

FastAPI + Encryption

↓

Payment Processors

↓

Celery Workers

↓

Real-time Monitor

↓

PostgreSQL Ledger

MCP-Powered AI Customer Support Assistant

MCP dynamic tool routingAuth-guarded API callsMulti-turn context

Conversational support assistant where user messages route through an MCP server that discovers and selects the right agent for the task. The selected agent calls account/card info APIs via MCP tool calls, passes through an auth guard (JWT), and the LLM synthesizes a contextual response. Built as a decoupled Next.js frontend with a FastAPI backend — no hardcoded tool logic, fully agent-driven.

LangChainMCPFastAPIOpenAI APIJWT / OAuth2RedisNext.jsPostgreSQL

// architecture flow

Chat UI (Next.js)

↓

FastAPI Backend

↓

MCP Server (Agent Router)

↓

Available Agents Discovery

↓

Card / Account Info API

↓

Auth Guard (JWT)

↓

LLM Response (OpenAI)

Freelance & Client Work

Karlisu

Full-featured e-commerce platform with product catalog, cart, checkout, and admin dashboard. Built for performance and conversions.

Next.jsNode.jsPostgreSQLStripeAWS

PyroTrack

Real-time tracking and analytics platform with live dashboards, data visualization, and automated alert systems.

ReactFastAPIWebSocketsRedisPostgreSQL

GetFoxCard

Fintech card management platform with secure user onboarding, virtual card issuance, and transaction history.

Next.jsNode.jsMongoDBOAuth2Docker

Open source

Published Python Packages

Real tools solving real problems — used by developers globally.

rabbitmq-easy

Simplifies RabbitMQ setup in Python microservices — solving critical connection and deployment conflicts that cost engineers hours. Used by developers globally.

pip install rabbitmq-easy

RabbitMQMicroservicesPythonMessage Queuing

api-watch

Production API monitoring and health-check CLI tool. Track uptime, response times, and set up automated alerts for your APIs — zero config needed.

pip install api-watch

API MonitoringDevOpsPythonCLI Tool

Let's connect

Ready to Build Something Great?

Whether it's a distributed system, an AI product, or a performance-critical API — I'm ready to jump in. Let's talk.

Send an Email WhatsApp Telegram

isadechair019@gmail.com · +254 759 856 000

Nairobi, Kenya — open to remote worldwide