Skip to main content
Glama

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.

CI Python 3.11+ License: MIT MCP

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-mcp

With npx, if Node is what you reach for:

npx -y islamqa-mcp

The 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"   # Windows

Claude Code

claude mcp add islamqa -- uvx --from git+https://github.com/RealYusufIsmail/islamqa-org-mcp islamqa-mcp

Claude 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 sync

Then 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 8000

The 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 shapesearch 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 8000

Then 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-mcp

It 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

search_fatwas

Full-text search across the archive. Filter by madhhab or source.

get_fatwa

One answer in full: question, answer, Arabic citations, issuing institution.

list_sources

All 47 darul ifta sites with per-site answer counts.

browse_fatwas

Most recent answers, optionally filtered.

index_status

Index size, cache size, last rebuild.

rebuild_index

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 status

How 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_fatwa

Because 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

/wp-json/

401{"code":"rest_disabled"}

/wp-json/wp/v2/posts

401rest_disabled

/wp-json/wp/v2/search

401rest_disabled

/wp-json/elasticpress/v1/search

401rest_disabled

/graphql, /api/

404

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

/sitemap_index.xml

XML

22 child sitemaps

/sitemap-posts.xml?page=N

XML

5,000 answer URLs per page, with lastmod

/feed/

RSS 2.0

Latest answers site-wide

/category/{madhhab}/{source}/feed/

RSS 2.0

Latest per institution

Answer pages

HTML + JSON-LD

NewsArticle schema carries publish/modify dates

/robots.txt

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-socks

If 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

ISLAMQA_DATA_DIR

~/.cache/islamqa-mcp

Where the index and cache live

ISLAMQA_REQUEST_DELAY

1.0

Seconds between requests

ISLAMQA_CACHE_TTL_DAYS

90

How long a cached answer stays fresh

ISLAMQA_INDEX_TTL_DAYS

30

When to rebuild the index

ISLAMQA_USER_AGENT

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_mcp

The 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 tools
browse_fatwasA
Read-only

List the most recent fatwas, optionally filtered to one madhhab or issuing source. For browsing; prefer search_fatwas to answer a specific question.

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoMaximum results.
offsetNoSkip this many results.
sourceNoIssuing site slug.
madhhabNoRestrict to one school.

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.5/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines5/5

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_fatwaA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesAn islamqa.org answer URL, as returned by search_fatwas.
refreshNoBypass the local cache and re-fetch the page.

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.3/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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_statusA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.3/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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_sourcesA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.5/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.4/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose4/5

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.

Usage Guidelines5/5

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_fatwasA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoMaximum results.
queryYesKeywords or a question, e.g. 'wiping over socks in wudu'.
sourceNoRestrict to one issuing site's slug, e.g. 'askimam'. See list_sources.
madhhabNoRestrict to one school of law.

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.8/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines4/5

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.

  1. 6 tool updatesv0.1.0
    • First observedbrowse_fatwas
    • First observedget_fatwa
    • First observedindex_status
    • First observedlist_sources
    • First observedrebuild_index
    • First observedsearch_fatwas

TDQS

A4.4/5.0

Scored across 6 tools

Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count5/5

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.

Completeness5/5

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

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables fetching and searching canonical hadith texts (Arabic and English) with cross-references and citation-safe URLs for assistants, built on FastMCP.
    2
    GPL 3.0
  • A
    license
    Not graded
    quality
    C
    maintenance
    MCP 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 npm
    MIT
  • F
    license
    A
    quality
    C
    maintenance
    Serves 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
    -