Pakistan Case Law
Server Details
Search 197,000+ Pakistani judgments by keyword, citation, or the legal question they settle.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
Available Tools
7 toolscaselaw_get_caseARead-onlyIdempotentInspect
Fetch one judgment by id.
section='summary' (default) returns metadata + the AI headnote (plain-language summary, the
laws/provisions referred, and keyword tags) — read this first to judge relevance cheaply.
section='full' additionally returns the judgment body text (capped at ~40,000 chars; the
response flags body_truncated/body_chars_total when longer).
| Name | Required | Description | Default |
|---|---|---|---|
| case_id | Yes | Numeric judgment id (from a search/lookup/graph result) | |
| section | No | 'summary' = metadata + AI headnote (cheap); 'full' = + judgment text | summary |
| response_format | No | markdown |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool as read-only and idempotent. The description adds significant behavioral detail beyond those annotations: what each section returns, the ~40,000-character cap on full text, and the body_truncated/body_chars_total flags. This gives an agent accurate expectations about cost and output limits.
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 compact and front-loaded, with each sentence earning its place. The main purpose comes first, followed by a structured explanation of the two sections and the truncation behavior. No filler or redundant restatement of the schema.
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 read-only single-record fetch tool with a strong schema and output schema, the description covers everything an agent needs: what each section contains, the default, the cost tradeoff, and the truncation signal. Nothing important 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 schema documents case_id and section, and the description enriches section semantics considerably: 'summary' includes metadata, AI headnote, laws/provisions, and keyword tags, while 'full' adds capped body text. The response_format parameter is not described, but its markdown/json enum is self-explanatory and does not create a meaningful gap.
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 opens with a specific verb and resource: 'Fetch one judgment by id.' It clearly distinguishes this tool from the sibling search/citation tools by targeting a single known case rather than querying or aggregating.
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 clear guidance within the tool: start with the cheap 'summary' section to judge relevance before requesting the full text. It does not explicitly name alternative tools for finding or searching cases, but the case_id source in the schema and the 'by id' phrasing make the intended usage clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
caselaw_get_citationsARead-onlyIdempotentInspect
Walk the citation graph FORWARD: list the in-corpus cases that THIS judgment cites (the precedents it relied on). Combine with caselaw_get_cited_by to traverse precedent backward and forward until a research question is resolved.
Most useful on RECENT judgments: a 2024-25 case usually has nobody citing it yet, but its
own citation list is a curated map of the established authority on the point.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| offset | No | ||
| case_id | Yes | Numeric judgment id | |
| response_format | No | markdown |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds behavioral context beyond annotations by specifying that the graph walk is forward-only, restricted to in-corpus cases, and that results represent the precedents relied upon by the given judgment. This is meaningful additional transparency.
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 compact and front-loaded: the first sentence states exactly what the tool does, the second clarifies the relationship with a sibling, and the final sentence gives a practical usage heuristic. Every sentence earns its place, with no filler 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 read-only listing tool with an output schema and strong annotations, the description covers the tool's purpose, direction, scope boundary (in-corpus), relationship to sibling tools, and a concrete use case. Pagination details are handled by the input schema defaults and constraints, so nothing essential is missing for correct invocation.
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 only 25%, with only case_id documented in the schema. The description provides no additional meaning for limit, offset, or response_format, and it does not compensate for the low schema coverage. The parameters are reasonably self-descriptive, but the description itself adds no semantic value beyond the schema.
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 and resource ('Walk the citation graph FORWARD: list the in-corpus cases that THIS judgment cites') and explicitly differentiates from caselaw_get_cited_by, which is the sibling that lists cases citing this judgment. The directionality is unambiguous, so an agent can select it correctly without guessing.
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 explicitly says to combine with caselaw_get_cited_by to traverse precedent backward and forward, and it gives a concrete usage scenario ('Most useful on RECENT judgments'). This is clear, actionable guidance that names the complementary alternative and explains when the tool provides the most value.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
caselaw_get_cited_byARead-onlyIdempotentInspect
Walk the citation graph BACKWARD: list later cases that cite THIS judgment (how it was subsequently treated — followed, distinguished, relied upon). Returns newest first.
Most useful on OLDER or landmark judgments: it shows whether the case is still followed and
where the principle has been applied since. A leading case can have hundreds of citing cases.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| offset | No | ||
| case_id | Yes | Numeric judgment id | |
| response_format | No | markdown |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish readOnly, idempotent, and non-destructive behavior. The description adds valuable behavioral context beyond those annotations: it explains the traversal direction, that results are returned newest first, and that large result sets are possible for leading cases. No contradiction with annotations exists.
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 compact, front-loaded with the core mechanism, and every sentence adds value: direction, citation meaning, ordering, use-case guidance, and a volume warning. There is no redundant filler.
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 read-only citation-listing tool, the description covers direction, ordering, use case, and scale. Annotations handle safety, and an output schema exists, so return-value details are not required here. Minor gaps such as explicit pagination advice or explicit sibling differentiation keep it from a perfect score.
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 only 25%, and the tool description does not compensate. It adds no meaning for limit, offset, or response_format beyond their schema titles and defaults, and it only indirectly refers to case_id as 'THIS judgment.' The low coverage means the description should have explained parameter behavior more explicitly.
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 precise verb and resource: 'Walk the citation graph BACKWARD: list later cases that cite THIS judgment.' It also clarifies the semantic content of the citations (followed, distinguished, relied upon), which clearly distinguishes this tool from sibling tools like caselaw_get_citations or caselaw_get_case.
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 clear context for when this tool is most useful: 'Most useful on OLDER or landmark judgments' and warns that 'A leading case can have hundreds of citing cases.' It does not explicitly name alternative tools or state when not to use it, but the backward-citation direction and use-case guidance make the intended usage clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
caselaw_lookup_citationARead-onlyIdempotentInspect
Find the judgment(s) at an exact law-report citation.
Example: journal='PLD', year=1995, page=34 → PLD 1995 Supreme Court 34.
Omit page to list everything reported in that journal+year. Returns the same case shape
as caselaw_search.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | Page/serial number in the report (optional) | |
| year | Yes | ||
| limit | No | ||
| offset | No | ||
| journal | Yes | Law-report code, e.g. 'PLD', 'SCMR', 'CLC' | |
| response_format | No | markdown |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral detail beyond those: exact-page matching, list-everything behavior when page is omitted, and the return shape being the same as caselaw_search.
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 short sentences with no filler. The core purpose is front-loaded, followed by a concrete example and the key page-omission nuance. 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?
For a lookup tool with strong annotations, an output schema, and well-named parameters, the description covers the essential behavior: exact citation lookup, page omission behavior, and output compatibility with caselaw_search. Remaining details like pagination and response format are sufficiently represented by the schema and defaults.
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 description adds meaningful semantics for the core params: journal and year through the example, and especially page, whose omission changes the result set. However, schema description coverage is only 33%, and limit, offset, and response_format receive no descriptive help from either the schema or the description.
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 action and resource: 'Find the judgment(s) at an exact law-report citation.' The example with journal='PLD', year=1995, page=34 makes the lookup concrete, and referencing caselaw_search helps distinguish this citation-lookup tool from search-based siblings.
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 invocation context: use it when you have an exact law-report citation, and explains the important behavioral alternative of omitting page to list everything in a journal+year. It does not explicitly name sibling alternatives or say when not to use them, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
caselaw_most_citedARead-onlyIdempotentInspect
List the most-cited (landmark) judgments in the corpus, ranked by how many other cases cite them. A good entry point for the leading authorities on Pakistani law.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| offset | No | ||
| response_format | No | markdown |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds meaningful behavioral context by specifying that results are ranked by citation count and that it returns landmark judgments, which goes 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?
The description is two sentences with zero fluff. The main purpose is front-loaded, and the landmark/ranking context is provided in a compact, readable way. Every word 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?
Combined with the rich annotations and presence of an output schema, the description is largely complete: it states what the tool returns, how results are ranked, and the legal domain. It does not mention pagination or output format behavior, but those are covered by the input schema and output schema, so the gap is minor.
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 0%, so the description must compensate for explaining parameters, but it does not mention limit, offset, or response_format at all. While the parameter names and defaults are reasonably self-explanatory, the description provides no additional semantics or usage hints, leaving the full burden on the schema.
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 verb ('List') and resource ('most-cited (landmark) judgments in the corpus'), with a precise ranking criterion ('by how many other cases cite them'). It does not explicitly differentiate from sibling tools, but the core purpose is unambiguous and distinct from search or individual case retrieval.
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 phrase 'A good entry point for the leading authorities on Pakistani law' gives contextual guidance on when to use the tool, implying it is for discovering landmark cases. However, it does not explicitly mention alternatives or state when not to use this tool versus siblings like caselaw_search or caselaw_get_cited_by.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
caselaw_searchARead-onlyIdempotentInspect
Full-text search of 197,000+ Pakistani judgments (Supreme Court & High Courts, 1970–2025).
Ranking follows how lawyers research: nearness to the legal point decides which cases are
returned; among comparably-near cases, more senior court > larger bench > more recent >
more cited. Use sort='newest' when you need the current state of the law (later judgments
supersede as statutes are amended), or sort='court' for the most authoritative first.
Returns ranked cases with id, title, citation, court, year, a snippet, and the public URL.
For an exact report citation use caselaw_lookup_citation. To read a case, pass its id to
caselaw_get_case.
| Name | Required | Description | Default |
|---|---|---|---|
| sort | No | relevance (default: nearest on the point, then court/bench/recency/citations) | newest (latest law first — useful because amendments supersede) | court (most senior court first) | relevance |
| limit | No | ||
| query | Yes | Keywords, e.g. 'bail murder 302' or 'khula dower' | |
| offset | No | ||
| response_format | No | markdown |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/idempotent/non-destructive, so the description's burden is lighter. It usefully adds ranking behavior (nearness to legal point, court/bench/recency/citations) and the returned fields, though it does not describe pagination/offset behavior beyond the schema.
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 short paragraphs: scope first, then ranking/sort behavior, then return fields and sibling routing. No filler and each sentence adds useful information.
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 five parameters and an output schema, the description is fully sufficient: it defines scope, ranking, sort semantics, return fields, and sibling alternatives. An agent can select and call this tool correctly with the information provided.
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 only 40%, so the description compensates by explaining what 'relevance' means through the ranking algorithm and when to use each sort value. Query semantics are implied by 'full-text search' and the schema's keyword examples. It does not add much about limit/offset/response_format, but those are conventional and partially encoded in the schema.
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?
Description states a specific action ('Full-text search') with a clear resource (197,000+ Pakistani judgments from Supreme Court & High Courts, 1970–2025). It distinguishes itself from sibling tools by naming caselaw_lookup_citation for exact citations and caselaw_get_case for reading a case.
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 explicit when-to-use guidance: sort='newest' for current law and sort='court' for authority, and names the sibling tools to use instead for citation lookup or reading a case. This is actionable routing without ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
caselaw_search_questionsARead-onlyIdempotentInspect
Find judgments by the QUESTION they settle, rather than by words they contain.
Every AI summary on this corpus records the questions that judgment actually decides — e.g.
"Does delay in lodging the FIR by itself entitle the accused to bail?" This searches those
questions, so it matches the shape a legal problem arrives in rather than the vocabulary a
1987 bench happened to use.
COVERAGE IS PARTIAL: questions exist for about 22,637 of 197,365 judgments (roughly one in
nine). An empty result means no *summarised* judgment matched — it does NOT mean no such
judgment exists. Fall back to caselaw_search, which covers the whole corpus.
The questions are written by an AI reading the judgment. They are a finding aid, not a
holding: cite the judgment, never the question. Pass an id to caselaw_get_case to read it.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | Yes | The legal question or its subject, in the words a judgment would use — 'delay in lodging FIR', 'concurrent findings of fact', 'pre-arrest bail murder' | |
| offset | No | ||
| response_format | No | markdown |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotation Contradiction: the description explicitly says coverage is partial and that an empty result 'does NOT mean no such judgment exists', while the annotations set openWorldHint to false, implying closed-world semantics where absence of a result is meaningful. This directly contradicts the annotation and could mislead an agent that trusts the structured metadata over the description.
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 longer than average but every section earns its place: purpose, source of the questions, coverage caveat, fallback, and usage caution. It is front-loaded with the core distinction, and the all-caps caveats make the most important warnings hard to miss.
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 read-only search tool with an output schema, the description covers everything an agent needs: what is searched, the coverage limitation, the alternative tool, the non-authoritative nature of the AI-written questions, and the next step via caselaw_get_case. 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 description coverage is only 25%, but the description substantially compensates for the critical required query parameter by explaining what kind of legal question to enter and providing concrete examples. The remaining parameters—limit, offset, and response_format—are left to names, defaults, and schema-defined choices, which is adequate for standard controls.
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 opening sentence states the verb, resource, and distinctive mechanism: 'Find judgments by the QUESTION they settle, rather than by words they contain.' This clearly separates it from caselaw_search without needing to inspect sibling definitions.
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 explicitly tells the agent when to prefer this tool—when matching the shape of a legal problem matters—and names the fallback: 'Fall back to caselaw_search, which covers the whole corpus.' It also explains what an empty result means, preventing the agent from drawing the wrong conclusion.
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. Dates show when Glama detected each change.
7 tool updates
- First observed
caselaw_get_case - First observed
caselaw_get_citations - First observed
caselaw_get_cited_by - First observed
caselaw_lookup_citation - First observed
caselaw_most_cited - First observed
caselaw_search - First observed
caselaw_search_questions
Frequently Asked Questions
Claiming proves that you control a remote MCP connector. It does not move, proxy, or interrupt the server.
Open the connector listing, choose Claim ownership, and sign in to Glama.
Complete one verification method:
GitHub identity — fastest for official registry listings. For a namespace such as
io.github.alice/server, link the matching GitHub user, then choose Claim with GitHub. An organization namespace such asio.github.acme/serveralso needs that organization to have installed the Glama AI GitHub App and approved its permissions, because GitHub discloses organization membership only to apps it has installed. Use HTTP or DNS when it has not.HTTP challenge — works when you can deploy a public file. Generate a token, publish the exact JSON Glama shows at
/.well-known/glama.jsonon the same origin as the connector, then choose Check HTTP challenge.DNS challenge — works when you control DNS but cannot change the server. Generate a token, create the exact TXT record Glama shows, wait for it to propagate, then choose Check DNS challenge.
After verification, Glama sends a confirmation email and gives you access to listing details, thumbnails, health checks, and analytics. Keep the HTTP file or DNS record in place: Glama periodically checks it and ownership remains verified while the token is discoverable.
The HTTP ownership file has this structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"claim": "glama_claim_..."
}Claim tokens are opaque, stable, and bound to the signed-in Glama account. They contain no email address or other personal information. If Glama can no longer discover a verified HTTP or DNS token, it starts a seven-day grace period before removing claim-based access. Restore the same token during that period to keep ownership verified. Never publish an email address, Glama session token, GitHub token, or connector credential as ownership proof.
If verification fails, confirm that you copied the current token exactly. The HTTP file must be public, return valid JSON with a successful HTTP response, and stay on the connector's origin. DNS changes may need more time to propagate. A claim cannot transfer to a different origin or hostname: if the connector target changes, Glama starts the grace period and the new target must be claimed separately after the previous claim is released.
For a connector linked to the official MCP Registry, registry updates continue to replace its name, description, and URL by default. After claiming, open Manage connector and enable Use Glama listing details as the source of truth if edits made on Glama should be preserved. Categories and thumbnails are always managed on Glama; registry linkage and technical connection settings continue to sync.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
To improve your MCP server's ranking:
Claim ownership of the server listing
Complete the server profile with an accurate description and thumbnail
Provide a test profile so Glama can connect to and evaluate the server
Keep tool definitions clear and complete to earn a high Tool Definition Quality Score (TDQS)
Route real usage through the Glama Gateway; more recorded successful server uses also improve the ranking
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!
Related MCP Connectors
Search 18M+ legal documents worldwide — case law, legislation, and doctrine across 110+ countries.
Malaysian court judgment search for Federal Court, Court of Appeal, High Court cases and parties.
Search and read Indonesian court cases. Filter by court, year, and case type.
Search and cite UAE law (federal, Dubai, Abu Dhabi, DIFC, ADGM) with verifiable citations.
Related MCP Servers
- AlicenseAqualityAmaintenanceMCP server for searching and retrieving Pakistani federal statutes and Supreme Court judgments with structured citations, using static HuggingFace datasets.6Apache 2.0
- AlicenseNot gradedqualityBmaintenanceProvides retrieval-grounded, citation-verified access to Philippine law and compliance, including statutes, jurisprudence, and government issuances across 15 compliance domains.1Apache 2.0
- AlicenseNot gradedqualityCmaintenanceProvides access to CanLII's Canadian legal information, enabling search and retrieval of court decisions, legislation, and citations through natural language.69MIT
- AlicenseAqualityAmaintenanceEnables evidence-first research on Indonesian law and sharia economic law by searching regulations, court decisions, fatwas, Quran/hadith, and turath sources, verifying citations, and tracing legal status across time. Provides MCP tools to retrieve sourced documents and analyze legal problems while failing closed when evidence is ambiguous.10MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.
TDQS
Each tool targets a clearly distinct operation: search, exact citation lookup, case retrieval, forward and backward citation traversal, landmark ranking, and question-based search. Even the potentially similar citation tools are explicitly differentiated by direction and purpose.
All tools share the caselaw_ prefix and snake_case style, making the family recognizable. Minor inconsistency exists because 'most_cited' lacks an imperative verb while the others use get/lookup/search.
Seven tools is well-scoped for a legal research server. Each tool earns its place by covering a distinct part of the research workflow without redundancy or bloat.
The surface covers the core legal research lifecycle: full-text search, question-based search, exact citation lookup, retrieving full judgments, and traversing citations in both directions. Partial coverage of question search is explicitly handled with a fallback, so there are no dead ends.