Gospel Library MCP Server
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., "@Gospel Library MCP ServerFind scriptures about faith in the New Testament"
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.
Gospel Library MCP Server
Unofficial tool. Not affiliated with or endorsed by The Church of Jesus Christ of Latter-day Saints. See DISCLAIMER.md for full details.
An MCP (Model Context Protocol) server that gives AI agents direct, structured access to the Church of Jesus Christ Gospel Library — scriptures, General Conference talks, handbooks, manuals, and magazines.
Compatible with any MCP-enabled AI agent, including GitHub Copilot CLI, Claude Desktop, Claude Code, Cursor, Windsurf, and others.
No API key required. No external service. Everything runs locally.
Search is powered by a local semantic vector index using the all-MiniLM-L6-v2 model. When the index is built, the agent finds articles by meaning — not just URL keywords. Content is served in your OS locale language automatically, with per-request language override support.
Requirements
Node.js ≥ 18
Any MCP-compatible AI agent (see setup below)
Related MCP server: bible-mcp
Quick Setup
The MCP server configuration format is the same across all agents. Pick your agent below.
GitHub Copilot CLI
Add to ~/.copilot/mcp-config.json (create if it doesn't exist):
{
"mcpServers": {
"gospel-library": {
"command": "npx",
"args": ["-y", "@jasonbellz/gospel-library-mcp"]
}
}
}Restart Copilot CLI and run /mcp — you should see gospel-library listed with 4 tools.
Claude Desktop
Add to your Claude Desktop config file:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"gospel-library": {
"command": "npx",
"args": ["-y", "@jasonbellz/gospel-library-mcp"]
}
}
}Restart Claude Desktop. The tools will be available automatically.
Claude Code (CLI)
claude mcp add gospel-library -- npx -y @jasonbellz/gospel-library-mcpCursor
Add to ~/.cursor/mcp.json (global) or .cursor/mcp.json (project-level):
{
"mcpServers": {
"gospel-library": {
"command": "npx",
"args": ["-y", "@jasonbellz/gospel-library-mcp"]
}
}
}Windsurf
Add to ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"gospel-library": {
"command": "npx",
"args": ["-y", "@jasonbellz/gospel-library-mcp"]
}
}
}Other MCP-Compatible Agents
Any agent that supports the MCP stdio transport uses the same mcpServers JSON block. Consult your agent's documentation for the config file location.
(Optional) Add Agent Instructions for Proactive Use
Tell your agent to use the Gospel Library tools automatically when answering Church-related questions. Add the following to your agent's system prompt or instructions file:
## Gospel Library MCP
You have access to an MCP server (`gospel-library`) that provides structured access to the
Church of Jesus Christ of Latter-day Saints Gospel Library at churchofjesuschrist.org.
Use the Gospel Library MCP tools whenever the user asks about:
- Church doctrine, teachings, or gospel principles
- Scriptures (Bible, Book of Mormon, Doctrine & Covenants, Pearl of Great Price)
- General Conference talks (1971–present)
- Church policies, handbooks, or guidelines
- Church history or historical documents
- Magazines (Liahona, Ensign, Friend, New Era)
- Church manuals or curriculum
When a question is clearly about Church topics, call the relevant tool FIRST before answering.GitHub Copilot CLI: add to
~/.copilot/copilot-instructions.mdClaude Desktop / Claude Code: add to your project's
CLAUDE.mdor system promptCursor: add to
.cursorrulesor project instructions
Building the Semantic Search Index
Without the index, search falls back to URL slug matching (still useful, just less precise). For semantic search — which finds articles by meaning rather than exact keywords — you need a local index.
Three options are available, from fastest to most thorough:
Option | Command | Size | Time | Quality |
Download (pre-built) |
| ~12.5 MB | ~30 sec | Good |
Standard build (truncated) |
| ~12–13 MB | ~45–90 min | Good |
Full build (chunked) |
| ~35–40 MB | ~2–4 hrs | Best |
Download full (pre-built chunked) |
| ~35–40 MB | ~1–2 min | Best |
Option 1: Download the Pre-Built Index (Recommended, ~30 seconds)
Download a pre-built index.db from the latest GitHub Release:
npx @jasonbellz/gospel-library-mcp download-indexSaves to ~/.gospel-library-mcp/index.db. Shows live download progress.
Option 2: Download the Pre-Built Full Index (~1–2 minutes)
Download the pre-built chunked index for best semantic coverage:
npx @jasonbellz/gospel-library-mcp download-index --fullSaves to ~/.gospel-library-mcp/index.db (replaces any existing index).
Option 3: Build the Standard Index Locally (~45–90 minutes)
Build from scratch by crawling the live sitemap. Each article is indexed using its full content, truncated to ~350 words (one embedding per article).
npx @jasonbellz/gospel-library-mcp build-indexWhat it does:
Downloads the English sitemaps (~50k URLs)
Filters to indexed categories: General Conference talks, General Handbook, Gospel Topics essays (~10,000+ pages)
Fetches and parses each page, using the first ~350 words as the embed text
Generates 384-dimension embeddings using
Xenova/all-MiniLM-L6-v2(runs locally, ~25 MB download on first run)Stores everything in
~/.gospel-library-mcp/index.db
Option 4: Build the Full Chunked Index Locally (~2–4 hours)
Build a deeper index where each article is split into overlapping ~350-word chunks. Produces multiple embeddings per article for full semantic coverage of long talks and handbook sections.
npx @jasonbellz/gospel-library-mcp build-index --fullWhen to use: When you want the best possible search quality and are willing to wait for the longer build. Especially useful for finding specific passages within long articles.
Refreshing After New Content
New General Conference talks are published in April and October. Run an incremental refresh — only new articles are fetched and embedded. The refresh automatically detects whether your current index is standard or full and uses the same mode:
npx @jasonbellz/gospel-library-mcp refreshExpected time: 1–5 minutes (a few hundred new articles per conference)
The MCP server automatically reminds you to refresh when the index is more than 30 days old.
Tools
search_gospel_library
Search the Gospel Library for articles, talks, scriptures, manuals, and policies.
When the index is built: uses cosine similarity over the local vector index for semantic search — finds articles by meaning. Before the index is built: falls back to URL slug keyword matching.
Parameter | Type | Required | Description |
| string | ✅ | The search query (e.g. |
| string | ❌ | Restrict results to a category. See Category Aliases below |
| number | ❌ | Max results to return (1–10, default 5) |
Category aliases (pass these as the category parameter):
Alias | Resolves to |
| All General Conference talks |
| All scripture content |
| All manuals and handbooks |
| General Handbook only |
| Liahona magazine |
| Ensign magazine |
| Friend magazine |
You can also pass any path relative to /study/ (e.g. general-conference/2024/10).
get_article
Fetch the full content of a specific article, talk, manual chapter, or policy page. Returns clean markdown.
Parameter | Type | Required | Description |
| string | ✅ | Full |
| string | ❌ | Language code (e.g. |
Example URL: https://www.churchofjesuschrist.org/study/general-conference/2024/10/12andersen?lang=eng
browse_category
List all articles and talks in a category or collection. Returns titles and URLs. Useful for browsing a specific conference session, scripture book, or magazine issue.
Parameter | Type | Required | Description |
| string | ✅ | Path relative to |
| string | ❌ | Language code (e.g. |
Common category paths:
Content | Path |
All General Conferences |
|
October 2024 Conference |
|
April 2025 Conference |
|
Book of Mormon |
|
New Testament |
|
Old Testament |
|
Doctrine & Covenants |
|
Pearl of Great Price |
|
General Handbook |
|
Gospel Topics |
|
Liahona (current) |
|
get_scripture
Fetch a specific scripture passage by reference. Parses the reference, constructs the Gospel Library URL, and returns the chapter content as markdown.
Parameter | Type | Required | Description |
| string | ✅ | Scripture reference (e.g. |
| string | ❌ | Language code (e.g. |
Supported reference formats:
Full chapter:
Genesis 1,Alma 32Single verse:
John 3:16,Moroni 10:4Verse range:
Moroni 10:4-5,D&C 76:22-24
Supported books and abbreviations:
Book | Abbreviations |
Genesis |
|
Exodus |
|
Leviticus |
|
Numbers |
|
Deuteronomy |
|
Joshua |
|
Judges |
|
Ruth | — |
1 Samuel |
|
2 Samuel |
|
1 Kings |
|
2 Kings |
|
1 Chronicles |
|
2 Chronicles |
|
Ezra | — |
Nehemiah |
|
Esther | — |
Job | — |
Psalms |
|
Proverbs |
|
Ecclesiastes |
|
Song of Solomon | — |
Isaiah |
|
Jeremiah |
|
Lamentations | — |
Ezekiel |
|
Daniel |
|
Hosea | — |
Joel | — |
Amos | — |
Obadiah | — |
Jonah | — |
Micah | — |
Nahum | — |
Habakkuk | — |
Zephaniah | — |
Haggai | — |
Zechariah |
|
Malachi | — |
Book | Abbreviations |
Matthew |
|
Mark | — |
Luke | — |
John | — |
Acts | — |
Romans |
|
1 Corinthians |
|
2 Corinthians |
|
Galatians |
|
Ephesians |
|
Philippians |
|
Colossians |
|
1 Thessalonians |
|
2 Thessalonians |
|
1 Timothy |
|
2 Timothy |
|
Titus | — |
Philemon | — |
Hebrews |
|
James | — |
1 Peter |
|
2 Peter |
|
1 John |
|
2 John |
|
3 John |
|
Jude | — |
Revelation |
|
Book | Abbreviations |
1 Nephi |
|
2 Nephi |
|
Jacob | — |
Enos | — |
Jarom | — |
Omni | — |
Words of Mormon | — |
Mosiah | — |
Alma | — |
Helaman |
|
3 Nephi |
|
4 Nephi |
|
Mormon |
|
Ether | — |
Moroni |
|
Book | Abbreviations |
Doctrine and Covenants |
|
Moses | — |
Abraham |
|
Joseph Smith History |
|
Joseph Smith Matthew |
|
Articles of Faith |
|
Multilingual Support
The MCP server automatically detects your OS locale at startup and serves content in that language. No configuration required.
How it works:
Search always uses the English index (cross-lingual retrieval — the embedding model is multilingual)
Content (
get_article,browse_category,get_scripture) is served in your OS locale language by defaultEvery tool accepts an optional
langparameter to override per-request
Override language per-request:
"Read Alma 32 in Spanish" →
get_scripture(reference: "Alma 32", lang: "spa")
"Get that talk in Portuguese" →
get_article(url: "...", lang: "por")
Supported language codes:
Code | Language | Code | Language |
| English |
| Spanish |
| Portuguese |
| French |
| German |
| Italian |
| Japanese |
| Korean |
| Chinese (Simplified) |
| Chinese (Traditional) |
| Russian |
| Filipino / Tagalog |
| Dutch |
| Swedish |
| Norwegian |
| Danish |
| Finnish |
| Polish |
| Ukrainian |
| Hungarian |
| Czech |
| Romanian |
| Bulgarian |
| Greek |
| Turkish |
| Arabic |
| Hebrew |
| Thai |
| Indonesian |
| Malay |
| Vietnamese |
| Khmer |
| Burmese |
| Mongolian |
| Samoan |
| Tongan |
| Hawaiian |
| Māori |
Note: Not all content is available in every language. English content is the most complete.
Files Created on Your System
Path | Purpose |
| SQLite vector index — standard (~12–13 MB) or full chunked (~35–40 MB) |
| Cached embedding model (~25 MB, downloaded once on first |
Agent config files (you create these — see Quick Setup above):
Agent | Config file |
GitHub Copilot CLI |
|
Claude Desktop (macOS) |
|
Claude Desktop (Windows) |
|
Cursor |
|
Windsurf |
|
Usage Examples
Semantic search:
"What does the Church teach about the Word of Wisdom?"
Finds articles about dietary law, health, and the Word of Wisdom — even articles where those words don't appear in the URL.
Scripture lookup:
"What does Moroni 10:4-5 say?"
Uses get_scripture to fetch the passage directly.
Browse a conference:
"List the talks from October 2024 General Conference"
Uses browse_category with general-conference/2024/10.
Read Church policy:
"What is the Church's policy on fast offerings?"
Uses search_gospel_library to find the relevant General Handbook section, then get_article to read it.
Local Development
git clone https://github.com/jasonbellz/gospel-library-mcp
cd gospel-library-mcp
npm install
npm run buildThen add dist/index.js as the command in your agent's MCP config:
{
"mcpServers": {
"gospel-library": {
"command": "node",
"args": ["/path/to/gospel-library-mcp/dist/index.js"]
}
}
}Or use node setup.js to auto-register with GitHub Copilot CLI, or node setup.js --npx to register using the published npm package.
Publishing a New Version
# 1. Bump version in package.json (e.g. 2.0.1)
npm version patch # or minor / major
# 2. Publish (build runs automatically via prepublishOnly)
npm publish --access public
# 3. Commit and push
git add package.json package-lock.json
git commit -m "chore: bump to vX.Y.Z"
git pushDisclaimer
This project is an independent, unofficial tool and is not affiliated with, endorsed by, or sponsored by The Church of Jesus Christ of Latter-day Saints.
The Church of Jesus Christ of Latter-day Saints, Book of Mormon, Liahona, Mormon, LDS, CTR, and FamilySearch are trademarks of The Church of Jesus Christ of Latter-day Saints or Intellectual Reserve, Inc., and may be registered in the United States of America and other countries. Use of these marks does not imply endorsement by or affiliation with The Church of Jesus Christ of Latter-day Saints.
All Gospel Library content accessed through this tool is the property of The Church of Jesus Christ of Latter-day Saints or Intellectual Reserve, Inc. This tool provides a programmatic interface to publicly accessible content at churchofjesuschrist.org and does not host, copy, or redistribute that content.
See DISCLAIMER.md for full details. For official trademark guidelines, visit churchofjesuschrist.org/reference/trademark-guidelines.
License
MIT © 2026 Jason Bell
Available Tools
4 toolsbrowse_categoryA
List articles and talks available in a Gospel Library category or collection. Returns titles and URLs. Useful for browsing conference sessions, scripture books, or magazine issues. IMPORTANT: Category paths must be exact. For manuals, paths are often year-specific — if you are unsure of the exact path, use search_gospel_library first to discover the correct URL. Come Follow Me paths include the year and audience, e.g. 'manual/come-follow-me-for-individuals-and-families-new-testament-2023' or 'manual/come-follow-me-for-sunday-school-new-testament-2023'. Do NOT guess a generic path like 'manual/come-follow-me' — it will 404. Specify lang to retrieve content in a different language. Defaults to OS locale language.
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | Optional language code. Examples: 'eng', 'spa', 'por', 'fra', 'deu'. Defaults to OS locale language. | |
| category | Yes | Exact category path relative to /study/. Examples: 'general-conference/2024/10' (Oct 2024 conference), 'general-conference/2025/04' (Apr 2025 conference), 'scriptures/bofm' (Book of Mormon), 'scriptures/nt' (New Testament), 'manual/general-handbook' (Church policies and procedures), 'manual/gospel-topics', 'manual/come-follow-me-for-individuals-and-families-new-testament-2023', 'manual/come-follow-me-for-sunday-school-new-testament-2023'. When unsure, call search_gospel_library first. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It adds critical context by specifying that category paths must be exact, wrong paths will 404, and offering a fallback strategy via search_gospel_library. It also notes the lang default behavior, going beyond the basic listing semantics.
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 front-loaded with the purpose and keeps critical warnings in the IMPORTANT section. It is somewhat long but every sentence earns its place, with no redundant or vague phrasing.
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?
This is a simple two-parameter tool with no output schema. The description covers purpose, use cases, parameter nuances, error behavior (404), and fallback to a sibling tool, making it complete for an agent to invoke correctly.
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?
Although the schema already covers both parameters (100% coverage), the description enriches the semantics with concrete path examples, warnings against generic paths, and an explicit default for lang. This adds meaningful value beyond the schema definitions.
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 lists articles and talks in a Gospel Library category, returns titles and URLs, and differentiates from siblings by focusing on browsing categories rather than searching or fetching single items.
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 identifies use cases ('browsing conference sessions, scripture books, or magazine issues'), tells the agent to use search_gospel_library first when unsure of a path, and warns against guessing generic paths that will 404. This provides strong when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_articleA
Fetch the full content of a specific Gospel Library article, talk, manual chapter, or policy page by URL. Returns clean markdown text. Use this after search_gospel_library to read the full content of an article. Specify lang to retrieve content in a different language (e.g. 'spa' for Spanish). Defaults to the OS locale language.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | The full URL of the article, e.g. 'https://www.churchofjesuschrist.org/study/general-conference/2024/10/12andersen?lang=eng' | |
| lang | No | Optional language code. Examples: 'eng' (English), 'spa' (Spanish), 'por' (Portuguese), 'fra' (French), 'deu' (German), 'jpn' (Japanese), 'kor' (Korean), 'zhs' (Chinese Simplified), 'zht' (Chinese Traditional), 'rus' (Russian). Defaults to OS locale language. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the transparency burden. It discloses that the tool returns clean markdown text and that lang defaults to the OS locale language, which adds meaningful behavioral context. It does not mention error cases or side effects, but for a read-only fetch tool the key behaviors are covered.
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 sentences, each earning its place: purpose and return type, usage context, and parameter behavior. The description is front-loaded with the primary action and is free of redundant phrasing.
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 two-parameter tool with no output schema, the description is sufficiently complete: it names supported content types, explains the return format, gives usage context relative to search_gospel_library, and documents language handling. No critical gaps remain for selecting and invoking this tool.
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%, so baseline is 3, but the description adds semantic clarity by explaining that the URL targets articles/talks/manual chapters/policy pages and explicitly links lang to language selection with an example. This goes slightly beyond what the schema provides.
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 opens with a specific verb ('Fetch') and a specific resource ('full content of a specific Gospel Library article, talk, manual chapter, or policy page by URL'), clearly distinguishing it from related tools like search_gospel_library (search) and get_scripture (scripture). It also names the return format ('clean markdown text'), making the 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?
The description explicitly states when to use it: 'Use this after search_gospel_library to read the full content of an article.' It gives clear context for language selection but does not explicitly mention when not to use it or alternatives like browse_category or get_scripture.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_scriptureA
Fetch a specific scripture passage by reference. Supports the Bible (Old and New Testament), Book of Mormon, Doctrine & Covenants, and Pearl of Great Price. Returns only the requested verse(s) as markdown. Specify lang to retrieve the passage in a different language. Defaults to OS locale language.
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | Optional language code. Examples: 'eng', 'spa', 'por', 'fra', 'deu'. Defaults to OS locale language. | |
| reference | Yes | Scripture reference in standard format. Examples: 'John 3:16', '2 Nephi 2:25', 'D&C 76:22', 'Moses 1:39', 'Alma 32:21', 'Moroni 10:4-5' |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the output format (markdown) and the language default behavior, which is helpful. Yet it does not mention what happens on invalid references, error handling, or any rate limits, leaving some behavioral gaps.
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 three sentences, each adding distinct value: purpose, return format, and language handling. It is concise, front-loaded, and contains no redundant or filler content.
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 low complexity (2 params, no output schema, no annotations), the description covers the main aspects: what it does, supported sources, return format, and language behavior. It could mention error handling or valid reference format validation, but it is largely complete for a simple fetch tool.
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 both parameters are already well-described. The description adds context about the return format being markdown and the language default, but it does not offer additional parameter-specific semantics beyond what the schema already provides. 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 uses a specific verb 'Fetch' with a clear resource 'scripture passage by reference' and explicitly lists the supported canons. This distinguishes it from sibling tools like search_gospel_library, which is for searching rather than direct reference lookup.
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 states the tool fetches a specific passage by reference, which implies the use case of having a known reference. However, it does not explicitly mention when to use this tool versus alternatives like search_gospel_library, nor does it provide exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_gospel_libraryA
Search the Church of Jesus Christ Gospel Library (churchofjesuschrist.org) for articles, talks, scriptures, manuals, and policies. Returns a list of matching articles with titles and URLs. No API key required. Use this proactively when answering questions about Church doctrine, policies, scriptures, or general conference talks.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | The search query (e.g. 'faith hope charity', 'law of tithing', 'word of wisdom') | |
| category | No | Optional category to restrict search. Examples: 'general-conference', 'scriptures', 'manual', 'liahona', 'ensign', 'friend', 'handbooks' | |
| maxResults | No | Maximum number of results to return (1-10, default 5) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden and does disclose 'No API key required' and the return format (list with titles and URLs). However, it omits potential edge cases (e.g., rate limits, empty results) and gives no detail on result pagination or ranking.
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 four short sentences, each adding distinct value: scope, return format, key requirement, and usage guidance. There is no redundancy or filler, and the main purpose 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?
The description covers purpose, usage context, return format, and authentication requirement. Given no output schema, it explains what is returned. However, it does not explicitly differentiate from sibling tools like get_article or browse_category, leaving a minor completeness gap.
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 covers 100% of parameter descriptions, including examples for query and category. The description adds no extra parameter semantics beyond what is already in the schema, so the baseline of 3 applies.
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 'Search' and resource 'Church of Jesus Christ Gospel Library (churchofjesuschrist.org)', and enumerates content types (articles, talks, scriptures, manuals, policies) and return format (list of titles and URLs). This clearly distinguishes it from siblings like get_article and browse_category.
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 advises to 'Use this proactively when answering questions about Church doctrine, policies, scriptures, or general conference talks,' providing clear when-to-use context. It does not mention when to prefer alternatives, but the proactive guidance is a strong usage signal.
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.
4 tool updates
v2.4.3- First observed
browse_category - First observed
get_article - First observed
get_scripture - First observed
search_gospel_library
TDQS
Scored across 4 tools
Each tool targets a distinct operation: search content, fetch article by URL, browse category listing, and retrieve scripture by reference. There is no functional overlap or ambiguity.
All tools follow a consistent verb_noun pattern using snake_case (search_gospel_library, get_article, browse_category, get_scripture), making the API predictable.
4 tools is appropriate for a focused read-only Gospel Library accessor, covering discovery and retrieval without unnecessary bloat.
The tool set covers the full reader journey: search, browse categories, fetch articles, and get scripture passages. No critical operations are missing for the stated purpose.
Maintenance
Related MCP Connectors
Scripture-cited answers to any Bible question, plus verse text and study pages, for AI agents.
Persistent memory and knowledge management for AI agents with semantic search and 50+ tools.
Universal persistent memory and knowledge retrieval layer for AI agents and LLMs.
Shared knowledge base for AI agents. Semantic search across agents, no setup required — just a URL.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables access to LDS Gospel Library content and scriptures through the Model Context Protocol. Provides tools for searching and retrieving religious texts and study materials from the Church of Jesus Christ of Latter-day Saints.2-
- FlicenseNot gradedqualityDmaintenanceEnables AI assistants to look up Bible verses, search across translations, and compare different versions locally without API keys.-
- AlicenseNot gradedqualityCmaintenanceEnables semantic search of the KJV Bible and personal knowledge graph for scripture study, notes, prayers, and memory verses, all running locally with no cloud dependencies.MIT
- AlicenseBqualityDmaintenanceEnables AI agents to access and interact with the Sefaria database of Jewish texts, including retrieval, search, and related content.281MIT