DEV Community: Irfan Ghapar

AI Fiqh & Retrieval-augmented generation (RAG)

Irfan Ghapar — Thu, 22 May 2025 06:39:41 +0000

Building AIFiqh: Our Journey with Islamic Knowledge and AI

How we're trying to make authentic Islamic scholarship more accessible (and learning a lot along the way)

Why We Built This Thing

Let me be straight here. When we started AIFiqh, we weren't trying to "disrupt" Islamic knowledge or whatever. We just noticed something annoying: finding reliable Islamic rulings online was a mess.

You'd search for something simple like "Can I pray with nail polish?" and get buried in forum discussions, random blog posts, and that one guy who's really confident but probably wrong. Meanwhile, there are literally hundreds of thousands of authentic Islamic texts sitting there, but good luck finding what you need without spending hours digging through PDFs.

So we thought: what if we could build something that actually knows this stuff?

When We Realized This Was Actually Hard

Turns out, building AI for Islamic knowledge isn't like building a chatbot for customer service. Islamic jurisprudence is nuanced. Context matters. Scholarly opinions differ. And you can't just throw GPT at it and hope for the best.

We learned this the hard way when our first prototype confidently told someone that "all fish are halal" without mentioning the Hanafi school's very specific opinions about shellfish. Oops.

That's when we realized we needed to get serious about this.

Why GPT and Claude Fall Short (And Why We Had to Build Our Own)

Before building AIFiqh, we tested the big players. Here's what we found:

Challenge	GPT-4	Claude	AIFiqh (Current)
Source Attribution	Generic responses, no citations	Limited Islamic sources	Every answer traces to specific kitab + page number
Madhab Awareness	Mixes schools without distinction	Occasional mention of differences	Clearly separates Hanafi, Maliki, Shafi'i, Hanbali opinions
Arabic Authenticity	Often paraphrases or translates incorrectly	Better than GPT but still limited	Original Arabic text + verified translations
Classical vs Contemporary	Can't distinguish scholarly weight	Similar issue	Properly weights classical scholars over modern opinions
Controversial Topics	Avoids or gives watered-down answers	Sometimes too cautious	Presents authentic scholarly positions with context
Update Frequency	Knowledge cutoff limitations	Same issue	Live updates from contemporary fatwa councils
Specialized Terminology	Generic Islamic terms	Better understanding but limited	Precise fiqh terminology with explanations
Infrastructure	Billion-dollar backing, global CDN	Well-funded, enterprise-grade	Running on startup budget (hoping investors are reading this 👀)

The Real Problem: General AI models are trained on everything—Wikipedia articles, random blogs, social media posts about Islam. They can't tell the difference between a authentic hadith commentary and someone's opinion on Reddit.

Our Problem: We know exactly what we need to build to compete with the big players, but we're currently bootstrapping this on DigitalOcean droplets while OpenAI has data centers around the world.

We needed something that actually knows the difference between Ibn Taymiyyah and that guy on IslamQA who's really confident but questionably qualified. But let's be honest, we also need the resources to scale this properly.

The Data Mission: 500K Texts and Counting

First things first: we needed the real deal. Not summaries, not interpretations, but actual source texts. So we went hunting.

What we digitized:

The entire Mausu'ah Fiqhiyyah Kuwaitiyah (all 45 volumes)
Al-Qardhawi's Fiqh Zakat
Hundreds of contemporary fatwas
Classical texts on muamalat
Tabung Haji documentation
And about 495,000 other texts that nearly broke our OCR budget

Converting these wasn't just scanning PDFs. Classical Arabic with diacritics, different fonts, handwritten marginalia, weird page layouts—our OCR pipeline had to handle it all. Fun times.

The Tech Stack (Or: How We Keep This Thing Running)

Frontend: React + Next.js

Because life's too short for vanilla JavaScript, and we needed SSR for performance.

Backend: The fun part we went multi-service:

Python + Flask for the heavy AI lifting
NestJS for our main API (TypeScript makes debugging less painful)
PostgreSQL + Prisma because we like our databases relational and our queries type-safe
ChromaDB for vector storage (more on this later)

AI Stack:

TensorFlow for our custom models
Google Gemini for the really tricky stuff
text-embedding-004 for turning Arabic text into numbers that actually mean something

Infrastructure: DigitalOcean everywhere

S3-compatible storage, droplets, managed databases—the works. No vendor lock-in headaches.

The Two-Tier Cache

Here's where it gets interesting. We built this two-tier caching system that's honestly kind of elegant:

Tier 1: The Speed Demon

LRU cache in memory. Sub-100ms responses for anything we've seen before. Because nobody wants to wait 3 seconds to find out if their prayer is valid.

Tier 2: The Brain

ChromaDB vector database with all our embeddings. When someone asks something new, we do semantic search across our entire corpus. Cosine similarity, 80% threshold, the works.

# This is simplified, but you get the idea
async def find_answer(question):
    # Check the fast cache first
    cached = await tier1_cache.get(question)
    if cached:
        return cached

    # Semantic search in the vector DB
    embedding = await embed_text(question)
    similar_texts = await vector_db.search(embedding, threshold=0.8)

    if similar_texts:
        answer = synthesize_answer(similar_texts)
        await tier1_cache.set(question, answer)
        return answer

    # Fall back to Gemini for novel questions
    return await gemini_generate(question, context=our_knowledge_base)

The cool part? If we don't have a good match in our vector DB, we fall back to Gemini but feed it relevant context from our texts. Best of both worlds.

Making Arabic Text Behave

Working with Arabic is... special. Different diacritics, right-to-left text, multiple valid spellings for the same word. Our preprocessing pipeline handles:

Normalization: Converting different Arabic fonts and diacritics to a standard form
Context preservation: Keeping track of which mazhab (school of thought) each text comes from
Citation tracking: Every piece of knowledge traces back to its source

We spent weeks just getting Arabic text to embed properly. Turns out, most embedding models are trained on English and get confused by Arabic morphology.

The UI: Making Knowledge Accessible

The interface is deliberately simple. Chat style interaction because that's what people expect from AI. But under the hood:

Source attribution for every answer (with Arabic text + translation)
Multiple perspectives when scholars disagree
Related questions to guide learning
Progressive disclosure so beginners don't get overwhelmed

We tried to make it clean, focused, and respectful. No flashy animations, just solid information architecture.

Testing Against the Big Players: A Reality Check

We ran some side-by-side comparisons during our beta. Here are real examples:

Query: "What's the ruling on cryptocurrency in Islam?"

GPT-4 Response: "Cryptocurrency is generally considered permissible in Islam, though some scholars have concerns about volatility and speculation..."

Claude Response: "Islamic scholars have different views on cryptocurrency. Some consider it halal while others have reservations due to gharar (uncertainty)..."

AIFiqh Response: "Contemporary scholars differ on cryptocurrency. Hanafi perspective (Dr. Monzer Kahf, 2018): Permissible as long as not used for gambling. Maliki perspective (European Council for Fatwa, 2019): Cautious approval with conditions. Concerns raised by Dar al-Ifta Egypt (2017): Excessive gharar and lack of intrinsic value. Source: Mausu'ah Fiqhiyyah Kuwaitiyah, Vol 31, pp. 234-237, plus contemporary fatwa compilation."

See the difference? We're not just giving opinions—we're showing you exactly where these opinions come from and how different schools approach the issue.

Real Talk: What We Got Wrong (And Fixed)

Performance Issues: Our first vector search was slow. Like, really slow. We fixed it with better indexing and parallel processing.

Cultural Blindspots: Beta users taught us things we never considered. Like how different communities have different transliteration preferences.

Source Weighting: Initially, we treated all texts equally. Bad idea. Classical scholars carry more weight than contemporary opinions, and our algorithm now reflects that.

Context Window: Arabic sentences can be really long. We had to tune our embedding strategy to capture complete thoughts without losing nuance.

The Numbers (Because Everyone Loves Metrics)

Current Performance:

555 active beta users across 50+ countries
33.35s average response time (we're working on this!)
4,562 total queries processed
66 queries today and growing

Data Scale:

500,000+ source texts processed
2.3M+ individual rulings extracted
50+ languages of source material
2MB average storage per user

What's Next (If We Can Keep the Servers Running)

Short term: We're working on voice interface (imagine asking fiqh questions while driving) and better mobile optimization. Assuming our DigitalOcean bill doesn't get too scary.

Medium term: Multi-language support, starting with Malay and Urdu. Also planning a scholar verification system—verified Islamic scholars can review and validate AI responses. This stuff needs proper funding though.

Long term: We want to build a complete Islamic knowledge graph. Imagine connecting every hadith to related Quranic verses and fiqh rulings automatically. Think Google's knowledge graph, but for Islamic scholarship. Obviously, this requires resources that match the ambition.

The Reality Check: We're currently a free tool serving 5,000+ users with bootstrap-level infrastructure. ChatGPT has billions in funding and global data centers. We have passion, authentic sources, and really good coffee.

If any investors are reading this: we've proven the concept works. Now we need to scale it properly. The Muslim community deserves AI that actually understands Islamic knowledge, not generic responses from models trained on Wikipedia.

The Human Element

Here's the thing about AI and religious knowledge: the technology is just a tool. We're not trying to replace scholars or traditional learning. We're trying to make authentic knowledge more accessible.

Every response includes source citations. We encourage users to verify important matters with qualified scholars. When scholars disagree, we show multiple perspectives.

The goal isn't to be the final authority it's to be a reliable starting point for learning.

Privacy & Ethics (The Boring But Important Stuff)

We don't sell user data. Ever.
Sensitive processing happens client-side when possible
Users can delete their data completely
We're transparent about our sources and limitations

Islamic knowledge is sacred. We treat it and our users with respect.

Behind the Scenes

Building this required more than just coding. We worked with Islamic scholars, studied classical Arabic, learned about different schools of jurisprudence. Our team spent months just understanding the domain before writing any code.

The technical challenges were real, but the cultural responsibility was bigger. Every design decision considered: "Does this serve the Muslim community well?"

Try It Yourself

AIFiqh is live at aifiqh.com. We're still in beta, still learning, still improving.

If you're a developer interested in Islamic tech, hit me up. If you're a scholar who wants to help improve our accuracy, we'd love to collaborate.

And if you're just someone who's ever struggled to find a clear Islamic ruling online well, that's exactly who we built this for.

Built with ❤️ by Muslims, for Muslims. Technical leadership by yours truly, with an amazing team of engineers and Islamic knowledge experts.

Current status: Beta (which means it's pretty good but we're still fixing things)

Questions? Feedback? Email us at hello@aiafiqh.com or better yet, try the platform and ask it directly.

Building DuitWise: A Personal Financial Management Solution for Malaysia

Irfan Ghapar — Wed, 04 Dec 2024 02:39:29 +0000

When our team won PayHack 2024, Malaysia's premier Open Finance hackathon, it wasn't just about building another fintech app. It was about solving a real problem that affects millions of Malaysians.

As the Technical Lead for DuitWise, I want to share our journey of building a solution that bridges the gap between traditional banking and modern financial needs while tackling the critical challenges of financial literacy and inclusion in Malaysia.
‎

The Challenge: Why We Built DuitWise

‎

The numbers were stark:

64% of Malaysian adults are financially illiterate
49.22% of bankruptcy cases are due to financial loans
6.1 out of 10 Malaysians struggle to access bank loans
48.4% still prefer cash transactions (rising to 63.5% in rural areas)

We saw an opportunity to create something that wasn't just another banking app, but a comprehensive financial companion that could help users like Mr. Hazwan, a Grab rider, and Mei Lin, a semi-urban farmer to make better financial decisions.

Technical Architecture

‎
At its core, DuitWise is built on three main pillars:
‎

1. Backend Infrastructure

‎

Client-Side Processing: We implemented a unique approach where computationally intensive tasks run on the mobile device, reducing server costs and improving response times
Mistral 7B Integration: A lightweight LLM for personalized financial advice
OCR Donut Transformer: For receipt processing and categorization
Python Scripts: For financial calculations and stress testing ‎ ‎

‎

2. Open Banking Integration

‎
We plan to integrate with major Malaysian banks through their Open APIs:

Maybank M2U Pay
CIMB API Gateway
Bank Islam Open Banking
GX Bank API ‎

‎

3. Frontend Development

‎
React Native: For cross-platform mobile development
Tailwind CSS: For consistent and responsive UI
Custom Components: Built reusable components for:
‎

Multi-bank dashboard
Financial fitness scoring
Loan stress testing
Digital receipt management

‎
‎

Key Technical Features

‎

1. ResitNow - Intelligent Receipt Management

Computer Vision model for receipt content extraction
Real-time tax relief and subsidy eligibility mapping
Automated categorization using Python backend

2. Financial Stress Testing

Real-time DSR (Debt Service Ratio) calculation
Integration with multiple bank APIs for comprehensive assessment
Machine learning model for personalized recommendations

Core Formula: Debt Service Ratio (DSR)
‎
The foundation of our loan stress testing is an enhanced version of the traditional Debt Service Ratio:

DSR = (New_Monthly_Commitment / Total_Income) × 100

where:
New_Monthly_Commitment = Current_Total_Loan + Current_Total_Commitment + New_Monthly_Payment

However, we knew this basic formula wasn't enough for gig workers. Here's how we enhanced it:

For gig workers, we implemented a weighted average system:

Income Stability Assessment

Weighted_Monthly_Income = (3M_avg × 0.5) + (6M_avg × 0.3) + (12M_avg × 0.2)

where:
3M_avg = Average income for last 3 months
6M_avg = Average income for last 6 months
12M_avg = Average income for last 12 months

3. DuitSmart AI Agent

Locally-run LLM for personalized financial advice
Real-time transaction analysis
Proactive investment suggestions based on user profile

The magic happens in how we process financial data. Here's a peek at our scoring algorithm:

Financial_Fitness = (0.3 × SR) + (0.25 × DM) + (0.2 × EFR) + (0.15 × IU) + (0.1 × ID)

‎
‎

Engineering Challenges and Solutions

1. Scale and Performance

To handle our projected user base (from 12k to 120k users), we implemented:

Client-side processing for CPU-intensive tasks
Efficient data storage (2MB per user)
Optimized API calls using caching

2. Security and Compliance

End-to-end encryption for financial data
Compliance with Bank Negara Malaysia regulations
Secure multi-bank authentication

3. User Experience

Offline-first architecture for rural users
Progressive enhancement for varying device capabilities
Sub-second response times for critical features

‎

Impact and Results

Our solution has the potential to:

Increase financial literacy by 35% ‎
Streamline targeted subsidy claims ‎
Empower 4 million gig workers with loan approval tools ‎
Help 15 million taxpayers with documentation ‎ ‎

Conclusion

DuitWise demonstrates how technology can solve real-world problems at scale. By combining AI, open banking, and user-centric design, we've created a solution that makes financial management accessible to all Malaysians.

The Team Behind the Tech
As Technical Lead, I worked with an amazing team:

This project was developed for PayHack 2024 by Team Barracuda. I served as the Technical Lead, focusing on architecture and implementation.

How I Built Be U Commit at Bank Islam

Irfan Ghapar — Tue, 12 Nov 2024 13:35:30 +0000

A Journey of Transforming Developer Productivity at Bank Islam

Sometimes the biggest innovations start with the smallest commits

The Be U Commit dashboard: Transforming raw git data into actionable team insights

It was a warm August morning in Kuala Lumpur when I walked into Bank Islam's Digital Banking division as a fresh-faced intern. Armed with nothing but my laptop and an unhealthy addiction to coffee, I was ready to take on the world - or at least try not to break the production environment.

Little did I know that within two months, I'd be building something that would change how one of Malaysia's largest banks thinks about developer productivity.

From Documentation to Discovery

Using an open-source AI approach, I transformed what was typically a time-consuming, error-prone documentation process into something more efficient. Instead of manually writing README files, I developed an injection script that could analyze repositories and generate comprehensive documentation automatically. What used to take a full day could now be completed in hours.

The same principle worked for our API documentation. Rather than having developers run separate libraries each time they needed to access API lists, we created a centralized system that made documentation accessible across all repositories. Small wins, but they hinted at bigger possibilities.

The Turning Point

Around day 25 of my internship, after swimming through oceans of README files and API docs, I noticed something. Our teams were scattered across different locations, working remotely, and no one had a clear picture of what was happening. AWS CodeCommit was being sunset, and our tech leads were struggling to track developer productivity.

"How do we know if our teams are truly productive?" I asked En. Hatta during one of our daily standups.

His response? "Why don't you figure it out?"

Building the Magic Machine

That's when Be U Commit started taking shape. I dove deep into research from Google's DevOps teams and Microsoft's assessment frameworks, but reading papers wasn't enough because we needed something real.

Developer productivity metrics framework based on Google's DevOps research and Microsoft's assessment methodology

Starting with rough sketches that turned into wireframes, I designed three core interfaces:

A Dashboard page showing total commits and pull requests
A Developers page displaying team metrics and rankings
Individual Developer profiles tracking personal growth

As a Product Engineer, I wasn't just designing but I need to build. Every component had to work seamlessly in our AWS infrastructure. The pipeline wasn't just about moving data but it was about transforming it into something meaningful.

From git commits to actionable insights: Be U Commit's data pipeline

Making Magic Happen

Bringing the MVP to life was like solving a puzzle where the pieces kept changing shape.

We needed to:

Process git logs in real-time
Calculate efficiency scores that actually meant something
Present data in a way that inspired rather than intimidated

The interface had to be more than just pretty charts where it needed to tell stories. Pull requests that used to take 16 hours started taking 9, not because we were pushing harder, but because we could see the bottlenecks clearly.

We built something special. Developers could see their impact in real-time. Team leads could identify who needed help before they even asked for it. The dashboard became less about metrics and more about mentorship.

The End (Or Is It?)

They say the best solutions come from really understanding the problem. In my case, it came from documenting hundreds of repositories and drinking way too much coffee. But isn't that how all good tech stories start?

Remember: Every git commit tells a story. We just built the storyteller.

Written by Irfan Ghapar, who went from being terrified of git merge conflicts to building a productivity dashboard that even git would be proud of.

P.S. No repositories were harmed in the making of this story. :)