islamqa-org-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@islamqa-org-mcpWhat is the Hanafi ruling on wiping over cotton socks in wudu?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
islamqa-org-mcp
Give Claude, Codex, and any other MCP client access to ~98,000 sourced fatwas.
An MCP server for IslamQA.org, which aggregates answers from 47 independent darul ifta institutions across the four Sunni madhahib.
Website · Install · ChatGPT · Tools · How it works · Etiquette
Why
Ask a language model a fiqh question and it will answer from a blur of training data, with no source, no madhhab, and no way to check it. That is the wrong shape for this kind of question.
This server changes the default. Your assistant searches a real archive of scholarly answers, and quotes one with the mufti, the madhhab, the institution, and a URL you can open. When the schools differ, you see that they differ instead of getting one position presented as the Islamic ruling.
You: Can I wipe over ordinary cotton socks in wudu?
Claude: [searches IslamQA.org]
The Hanafi position (Askimam.org, Mufti Ebrahim Desai) is that masah
is only valid on socks with the characteristics of leather khuffayn —
thick enough that water does not seep through, able to stand upright
unaided, and durable over three to four miles of walking. Ordinary
cotton socks do not qualify.
https://islamqa.org/hanafi/askimam/127638/...
Bin Bayyah (Maliki) notes the Hanbali school permits wiping over cloth
socks, while the Maliki position restricts it to leather.
https://islamqa.org/maliki/binbayyah/29891/...Related MCP server: quran-mcp
Install
No clone, no manual setup. Pick whichever runner you already have.
With uv (recommended — it's what actually runs the server):
uvx --from git+https://github.com/RealYusufIsmail/islamqa-org-mcp islamqa-mcpWith npx, if Node is what you reach for:
npx -y islamqa-mcpThe npm package is a thin wrapper — it hands off to uv, which fetches and
runs the Python server in an isolated cached environment. You still need uv
installed; the wrapper tells you how if it's missing.
curl -LsSf https://astral.sh/uv/install.sh | sh # macOS / Linux
brew install uv # Homebrew
powershell -c "irm https://astral.sh/uv/install.ps1 | iex" # WindowsClaude Code
claude mcp add islamqa -- uvx --from git+https://github.com/RealYusufIsmail/islamqa-org-mcp islamqa-mcpClaude Desktop
Add to claude_desktop_config.json — on macOS,
~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"islamqa": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/RealYusufIsmail/islamqa-org-mcp",
"islamqa-mcp"
]
}
}
}Codex
Add to ~/.codex/config.toml:
[mcp_servers.islamqa]
command = "uvx"
args = ["--from", "git+https://github.com/RealYusufIsmail/islamqa-org-mcp", "islamqa-mcp"]Restart the client. The first search builds a local index (about a minute, ~22 requests); everything after that is instant.
git clone https://github.com/RealYusufIsmail/islamqa-org-mcp.git
cd islamqa-org-mcp && uv syncThen point the client at it with
uv --directory /absolute/path/to/islamqa-org-mcp run islamqa-mcp.
ChatGPT
ChatGPT is different from the clients above: it can't launch a local process, so it needs the server hosted at a public HTTPS URL. Two things follow.
1. Run it over HTTP instead of stdio.
islamqa-mcp --transport streamable-http --host 0.0.0.0 --port 8000The endpoint ChatGPT wants is then https://your-host/mcp.
2. It exposes search and fetch in this mode. ChatGPT rejects any
connector that doesn't have tools by exactly those names unless you've turned on
Developer Mode, and Deep Research only ever calls those two. So when running
over HTTP the server adds them as adapters over search_fatwas / get_fatwa,
in OpenAI's required shape —
search returns {id, title, url} per result, fetch returns
{id, title, text, url, metadata}. Every result carries a real islamqa.org
URL, so ChatGPT renders proper citations.
They are not registered for stdio, deliberately: Claude and Codex get the
richer search_fatwas, and adding a weaker alias would just invite them to use
the worse one.
Trying it without deploying
Run it locally and point a tunnel at it — this is what the Tunnel toggle in ChatGPT's connector dialog is for:
islamqa-mcp --transport streamable-http --port 8000
cloudflared tunnel --url http://localhost:8000 # or: ngrok http 8000Then in ChatGPT: Settings → Apps → Advanced → Developer mode, add a
connector pointing at https://<your-tunnel>/mcp, authentication None.
Hosting it properly
A Dockerfile is included and works on Render, Railway, Fly.io or Cloud Run:
docker build -t islamqa-mcp .
docker run -p 8000:8000 islamqa-mcpIt builds the URL index at image build time, which matters: the index costs ~22 requests to islamqa.org, and baking it into the image means that happens once per release rather than on every cold start of every replica. Without that, an autoscaling free tier would re-crawl the sitemap all day. It also makes the first user search instant.
Before you expose it publicly: a connector with no authentication is open to anyone who finds the URL, and every request they make is a request against islamqa.org under your server's name. Put it behind OAuth or an auth proxy if it isn't just for you, and keep the rate limit where it is.
The skill
An MCP server gives the model tools. It doesn't tell it how to use them well — and for fiqh, how matters more than what.
skills/islamqa-fatwa is a
Claude skill
that ships alongside the server. It makes the assistant:
Ask which madhhab you follow before answering — or present all four positions side by side if you don't follow one
Never issue a ruling it didn't retrieve. No invented hadith, no half-remembered "the Hanafi view is…", no fabricated Arabic citations. If the archive has nothing, it says so instead of filling the gap
Use the tradition's actual categories rather than flattening everything to halal/haram — including the Hanafi seven-fold scheme, so makrūh taḥrīmī isn't quietly downgraded to "disliked" or upgraded to "haram"
Say when coverage is thin. The archive is heavily Hanafi; if there's no Maliki answer, it reports that rather than inferring one
Refer on for divorce, inheritance, custody and other matters that need a person rather than a search index
Install it globally:
git clone https://github.com/RealYusufIsmail/islamqa-org-mcp.git /tmp/islamqa-mcp
cp -r /tmp/islamqa-mcp/skills/islamqa-fatwa ~/.claude/skills/It activates on its own when a question turns out to be a ruling question.
Tools
Tool | What it does |
| Full-text search across the archive. Filter by |
| One answer in full: question, answer, Arabic citations, issuing institution. |
| All 47 darul ifta sites with per-site answer counts. |
| Most recent answers, optionally filtered. |
| Index size, cache size, last rebuild. |
| Refresh the index from the sitemap. Rarely needed. |
Over HTTP, search and fetch are added for ChatGPT compatibility — see
ChatGPT.
Every answer is returned with its attribution and a note reminding the model to cite the URL and to treat the ruling as one mufti's position, not a universal one.
Command line
The same operations without an MCP client:
uv run islamqa search "wiping over socks" --madhhab hanafi
uv run islamqa get https://islamqa.org/hanafi/askimam/127638/can-i-wipe-make-masah-over-the-new-socks/
uv run islamqa sources
uv run islamqa statusHow it works
IslamQA.org runs WordPress with the REST API disabled, so there is no JSON endpoint to call. What it does publish is a complete sitemap and server-rendered pages — the same public pages any reader or search engine crawler sees.
The server works in two layers:
The index. One pass over the sitemap (~22 requests) records every answer URL along with its ID, madhhab, issuing source and a title derived from the slug. That is ~98,000 answers for a few megabytes and about a minute, and it means search is local and instant from then on.
The cache. Reading an answer fetches and parses that one page, then stores it. Search runs on an SQLite FTS5 index over both layers, so an answer is findable by title immediately and by its full text once anyone has read it — the archive gets more searchable the more you use it.
sitemap ──► index (~98k URLs + titles) ──┐
├──► FTS5 (BM25) ──► search_fatwas
answer page ──► parse ──► cache (full) ──┘ get_fatwaBecause answers were imported from 47 different sites over many years, pages
come in three template shapes, and all three are handled: the modern
.ai-question / .ai-answer-content wrappers; bare paragraphs with explicit
Question: / Answer: labels; and bare paragraphs with no labels at all. Stray
Q: prefixes and trailing "Original Source Link" text are stripped, and Arabic
endnotes citing classical texts are split into a separate citations field, so
an answer reads cleanly without losing the evidence behind it.
Does islamqa.org have an API?
No public JSON API. The site runs WordPress, but the REST API is switched off site-wide. Probed August 2026:
Endpoint | Result |
|
|
|
|
|
|
|
|
|
|
The on-site search box is rendered client-side by ElasticPress, so its results aren't in the HTML either — which is why this server builds its own index rather than proxying site search.
What is machine-readable and open:
Endpoint | Format | Notes |
| XML | 22 child sitemaps |
| XML | 5,000 answer URLs per page, with |
| RSS 2.0 | Latest answers site-wide |
| RSS 2.0 | Latest per institution |
Answer pages | HTML + JSON-LD |
|
| — | Served empty: nothing disallowed |
This server uses the sitemap and the answer pages. The RSS feeds are a lightweight option if you only want new answers and don't need search — they need no index and no scraping:
curl -s https://islamqa.org/hanafi/askimam/feed/Answer URLs are structured, so you can address any answer directly:
https://islamqa.org/{madhhab}/{source}/{post_id}/{slug}/
hanafi askimam 127638 can-i-wipe-make-masah-over-the-new-socksIf islamqa.org ever enables its REST API, this server should switch to it — open an issue if you notice it come back.
Configuration
All optional, set as environment variables:
Variable | Default | Purpose |
|
| Where the index and cache live |
|
| Seconds between requests |
|
| How long a cached answer stays fresh |
|
| When to rebuild the index |
| identifies this tool | Sent with every request |
Etiquette (adab)
This reads a free service run on donations, so it is built to be a good guest:
One request per second, serialised globally — concurrent tool calls cannot fan out into a burst.
Caches aggressively. Fatwas are effectively immutable once published, so a page is fetched once and reused for 90 days.
Fetches only what is asked for. The bulk pass reads the sitemap, not 100,000 answer pages. There is no crawler here.
Identifies itself with a real User-Agent pointing back to this repo.
Locked to one host. Every URL is checked against an allowlist before a socket opens, so no argument from a model can turn this into an open proxy.
Attributes everything. The issuing institution, the mufti where named, and a link to the darul ifta's own copy travel with every answer.
If you maintain islamqa.org and want anything changed here — the rate limit, the User-Agent, or the tool's existence — please open an issue and it will be addressed.
On using this. These are answers from qualified muftis, but a fatwa is given to a particular person in a particular context. A search result is not a ruling on your situation, and a language model relaying one is not a scholar. For anything consequential, ask a qualified person directly.
Development
uv sync --extra dev
uv run pytest # 81 tests, no network — runs against saved fixtures
uv run ruff check .
uv run mypy src/islamqa_mcpThe parser tests run against trimmed copies of real pages. If islamqa.org changes its template they fail loudly, which is deliberate: a silent parse regression would quietly feed empty answers to the model.
Licence
MIT — see LICENSE.
The licence covers this software only. The fatwas belong to the scholars and institutions that issued them. This tool reads public pages and links back; it does not redistribute the archive.
Available Tools
6 toolsbrowse_fatwasARead-only
List the most recent fatwas, optionally filtered to one madhhab or issuing source. For browsing; prefer search_fatwas to answer a specific question.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum results. | |
| offset | No | Skip this many results. | |
| source | No | Issuing site slug. | |
| madhhab | No | Restrict to one school. |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that it returns the 'most recent' fatwas (ordering behavior) and mentions optional filters, which goes beyond annotations. It omits details like pagination, but that is standard and the bar is lower given the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no filler. The first sentence delivers the core function, the second gives usage guidance. It is front-loaded and every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema, so the return format is covered. Annotations handle safety. The description covers the purpose, filtering, and usage distinction. For a read-only browse tool with optional filters, nothing essential is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with each parameter (limit, offset, source, madhhab) already described. The description only reiterates the madhhab and source filters ('optionally filtered to one madhhab or issuing source') without adding new semantics, so it adds marginal value beyond the schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('List') and resource ('most recent fatwas'), and explicitly differentiates from the sibling search_fatwas by noting that browsing is for exploration while search is for specific questions. This makes the tool's purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly says 'For browsing; prefer search_fatwas to answer a specific question.' This gives clear when-to-use guidance and a direct alternative, which is exactly what the dimension asks for.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_fatwaARead-only
Fetch one full fatwa from IslamQA.org by URL: the original question, the mufti's answer, the Arabic citations of classical texts, the issuing darul ifta and a link to their own copy. Cached locally after the first read.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | An islamqa.org answer URL, as returned by search_fatwas. | |
| refresh | No | Bypass the local cache and re-fetch the page. |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds valuable behavioral context beyond annotations: it discloses local caching after first read and the existence of a refresh parameter to bypass cache. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no fluff. The main purpose is front-loaded, and the caching/refresh detail is placed logically after. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With annotations covering safety and an output schema present (stated in context), the description covers the essential usage details: what it fetches, the source URL, and caching behavior. An agent can call it correctly without additional information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with both url and refresh already well-described in the schema. The description adds the note 'as returned by search_fatwas' for url and mentions caching for refresh, but both are also implied in the schema. Baseline 3 is appropriate since the description adds minimal extra meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool fetches one full fatwa by URL and enumerates the specific content (question, answer, citations, issuing darul ifta, link). This is a specific verb+resource and distinguishes it from sibling tools like search_fatwas (search) and browse_fatwas (browse).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description notes the URL comes from search_fatwas, which implies its usage context, and mentions caching behavior. However, it does not explicitly state when to prefer this over alternatives or provide when-not-to-use guidance. The context is clear but lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
index_statusARead-only
Report how many fatwas are indexed, how many have been read into the local full-text cache, and when the index was last rebuilt.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool is clearly a safe read operation. The description adds valuable context by specifying exactly what metrics are reported (number indexed, number in cache, last rebuild time), which goes beyond the annotations. It does not contradict the annotations and provides helpful detail about the tool's output.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that immediately states the core function. It is front-loaded with the action ('Report') and lists the three key metrics in a clear, organized manner. There is no redundancy or filler, making it highly efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, no complex inputs) and the presence of an output schema, the description is complete. It explains what the tool reports without needing to describe return values (which are covered by the output schema). For a status-reporting tool with this straightforward scope, nothing essential is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema is trivially 100% described. The description does not need to explain parameters, and the baseline for zero-parameter tools is 4. The description focuses on the output, which is appropriate given there are no inputs to clarify.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: reporting on fatwa index status, including counts and last rebuild time. It uses the specific verb 'report' with a clear resource 'index status', and it distinguishes itself from siblings like search_fatwas, list_sources, get_fatwa, and rebuild_index by focusing on status metrics rather than data retrieval or modification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for checking index health and statistics, but it does not explicitly state when to use this tool versus alternatives. For instance, it doesn't mention 'use this before searching to ensure the index is up-to-date' or 'use this to diagnose why search results may be incomplete.' The purpose makes usage obvious, but there is no explicit guidance or mention of exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_sourcesARead-only
List every darul ifta indexed by IslamQA.org, grouped by madhhab, with how many answers each contributed. Use to discover valid 'source' values for search_fatwas, or to see how the schools are represented.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover readOnlyHint and destructiveHint, so the description adds value by disclosing that the list is exhaustive ('every'), grouped by madhhab, and includes answer counts. These are behavioral traits beyond the safety annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste: the first states the core function, the second gives actionable usage guidance. The most important information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return format details are unnecessary. The description covers purpose, scope, grouping, and ties to sibling usage, making it fully adequate for an agent to know when and why to call it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema coverage is 100%, so there is nothing to explain. The description correctly focuses on what the output provides (grouped list with counts), which still aids the agent in interpreting results.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (list) and resource (darul ifta indexed by IslamQA.org), with grouping and count detail. It also explicitly ties to searching for valid source values, distinguishing it from sibling tools like search_fatwas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives clear, explicit use cases ('discover valid source values' and 'see how schools are represented') and implicitly positions it as a prerequisite to search_fatwas. It does not state when not to use it, but the purpose is sufficiently distinct from siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
rebuild_indexA
Rebuild the local URL index from islamqa.org's sitemap. Rarely needed — the index builds itself on first search and refreshes when stale. Takes about a minute and makes roughly 22 requests to the site.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations (readOnlyHint: false, destructiveHint: false, openWorldHint: true) are already present, but the description adds concrete behavioral details: it takes ~1 minute and makes ~22 requests to an external site. This discloses side effects (network traffic, delay) beyond the annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three efficient sentences: purpose, when-to-use, and cost. Every sentence adds value and the most important guidance (rarely needed) is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, side-effectful maintenance tool, the description covers purpose, usage context, behavior, and cost. The presence of an output schema further reduces the need to explain return values. Nothing essential is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema already fully documents this aspect (coverage 100%). No parameter description is needed; the baseline of 4 applies since there's nothing to add.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Rebuild') and resource ('local URL index from islamqa.org's sitemap'), making the core function clear. It does not explicitly differentiate from siblings like index_status, but the uniqueness is implied given it's a one-off maintenance operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Rarely needed' and explains the index 'builds itself on first search and refreshes when stale.' This gives clear guidance on when NOT to call it and contrasts with automatic behavior. Also adds cost information (time, requests) that discourages casual use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_fatwasARead-only
Search roughly 100,000 fatwas (Islamic legal answers) on IslamQA.org by keyword or question. Use this whenever a question concerns Islamic rulings, fiqh, worship or practice and you want sourced scholarly answers rather than your own knowledge. Returns ranked results with title, madhhab, issuing source and URL; call get_fatwa on a result to read the full answer.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum results. | |
| query | Yes | Keywords or a question, e.g. 'wiping over socks in wudu'. | |
| source | No | Restrict to one issuing site's slug, e.g. 'askimam'. See list_sources. | |
| madhhab | No | Restrict to one school of law. |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful behavioral details: it returns ranked results with title, madhhab, source and URL, and explicitly says the full text requires a separate get_fatwa call. However, it does not mention pagination, sorting behavior, or any rate limits, so transparency is only partially enhanced beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two well-structured sentences, with the core purpose front-loaded and the usage guidance following. Every sentence earns its place, providing purpose, scope, result format, and a directive to the next step without any fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with an existing output schema and clear annotations, the description provides sufficient context: when to use, what results contain, and how to proceed (call get_fatwa). It omits any explanation of limit semantics or result ordering, but the schema covers limits and the output schema defines the return structure, so the description is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all four parameters are already documented in the schema. The description adds value by giving an example query ('wiping over socks in wudu') and by explicitly pointing to list_sources when using the source parameter. Yet it does not explain parameter relationships or default behaviors beyond what the schema already states.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action (search) on a specific resource (fatwas on IslamQA.org) and the scope (keyword or question). It also distinguishes itself from siblings like get_fatwa by noting that it returns summaries and that full answers require a follow-up call, though it doesn't explicitly contrast with browse_fatwas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit guidance on when to use the tool ('whenever a question concerns Islamic rulings, fiqh, worship or practice and you want sourced scholarly answers rather than your own knowledge') and provides a clear trigger condition. It also hints at an alternative (using own knowledge) but does not explicitly mention when to use siblings like browse_fatwas, so a small gap remains.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
v0.1.0- First observed
browse_fatwas - First observed
get_fatwa - First observed
index_status - First observed
list_sources - First observed
rebuild_index - First observed
search_fatwas
TDQS
Scored across 6 tools
Each tool serves a unique, clearly defined purpose: search for fatwas, browse recent ones, fetch a specific fatwa, list sources, check index status, and rebuild the index. There is no overlap or ambiguity between them.
All six tools follow the verb_noun pattern in snake_case (search_fatwas, list_sources, get_fatwa, browse_fatwas, index_status, rebuild_index), with consistent verb choices that clearly indicate the action taken.
Six tools is well within the ideal range for a domain-specific server. Each tool is necessary and none are redundant; the count is neither too sparse nor too heavy for the server's stated purpose of accessing IslamQA fatwas.
The tool surface covers the full workflow: searching, browsing, retrieving individual fatwas, understanding available sources, and maintaining the local index. There are no obvious missing operations for a read-only scholarly answer API.
Maintenance
Related MCP Connectors
Search and retrieve Quran ayahs, tafsir commentary, hadith, and detailed hadith records.
Live AI-native web search with citations. One tool for every MCP client. Flat per-request pricing.
Semantic search across 6,236 Quran verses and 12,416 authentic Hadiths for Islamic guidance.
- DikeOAuthio.github.fr3on
Grounded MENA legal search, reasoning, citation resolution, and citation-graph traversal.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables fetching and searching canonical hadith texts (Arabic and English) with cross-references and citation-safe URLs for assistants, built on FastMCP.2GPL 3.0
- FlicenseNot gradedqualityDmaintenanceProvides canonical Quran text, translations, and tafsir commentary via MCP for accurate AI citation.87-
- AlicenseNot gradedqualityCmaintenanceMCP server to search and retrieve passages from a corpus of 7,872 classical Islamic books via the Sahifah API, with full citations and mu'tabar filtering.9 npmMIT
- FlicenseAqualityCmaintenanceServes a scholar-approved Islamic corpus of Qur'an and hadith passages to any MCP client with server-side refusal enforcement. Enables natural-language questioning, retrieval, policy checking, and honest corpus coverage reporting while preventing fabricated answers.6-