The Sefaria Jewish Library MCP Server allows Large Language Models to interact with Jewish texts through a standardized interface.
Retrieve specific Jewish texts: Use the get_text tool to fetch a text by its reference (e.g., "Genesis 1:1" or "שמות פרק ב פסוק ג").
Retrieve commentaries: Use the get_commentaries tool to get a list of commentaries for a given text reference.
Search Jewish texts: Use the search_texts tool to search the Sefaria library with a query, filters, and customizable parameters like result size and slop for word distance.
Provides access to Jewish texts from the Sefaria digital library through tools for retrieving specific texts by reference, obtaining commentaries on a given text, and searching the library with customizable filters.
Click on "Install 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., "@Sefaria Jewish Library MCP Server get the text of Genesis 1:1"
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.
An MCP (Model Context Protocol) server that provides access to Jewish texts from the Sefaria library. This server enables Large Language Models to retrieve and reference Jewish texts through a standardized interface.
Retrieve Jewish texts by reference
Retrieve commentaries on a given text
Search the Jewish library for a query
Get daily/weekly learning schedule from Sefaria's calendar
Related MCP server: Sefaria Jewish Library MCP Server
Requires Python 3.10 or higher.
git clone https://github.com/sivan22/mcp-sefaria-server.git
cd mcp-sefaria-serverThe server can be run directly:
uv --directory path/to/directory run sefaria_jewish_libraryOr through an MCP client that supports the Model Context Protocol. for claude desktop app and cline you should use the following config:
{
"mcpServers": {
"sefaria_jewish_library": {
"command": "uv",
"args": [
"--directory",
"absolute/path/to/mcp-sefaria-server",
"run",
"sefaria_jewish_library"
],
"env": {
"PYTHONIOENCODING": "utf-8"
}
}
}
}To install Sefaria Jewish Library for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install mcp-sefaria-server --client claudeThe server provides the following tools through the MCP interface:
Retrieves a specific Jewish text by its reference.
Example:
reference: "Genesis 1:1"
reference: "שמות פרק ב פסוק ג"
reference: "משנה ברכות פרק א משנה א"Retrieves a list of commentaries for a given text.
Example:
reference: "Genesis 1:1"
reference: "שמות פרק ב פסוק ג"
reference: "משנה ברכות פרק א משנה א"Searches for Jewish texts in the Sefaria library based on a query.
Example:
query: "moshiach"
slop: 1
filters: ["Talmud", "Bavli"]
size: 5Retrieves the daily or weekly learning schedule from Sefaria's calendar API.
Parameters (all optional):
diaspora (boolean): When true, returns weekly Torah reading for diaspora. When false, returns Torah reading for Israel. Default: true
custom (string): If available, the weekly Haftarah will be returned for the selected custom
year, month, day (integers): Specific date (all three must be used together, or API falls back to current date)
timezone (string): Timezone name in accordance with IANA Standards
Example:
# Get current day's learning schedule
{}
# Get learning schedule for a specific date in Israel
{
"diaspora": false,
"year": 2024,
"month": 12,
"day": 25,
"timezone": "Asia/Jerusalem"
}Returns a formatted schedule including:
Weekly Torah portion (Parashat Hashavua) with aliyot
Haftarah reading
Daf Yomi (daily Talmud page)
Daily Mishnah, Rambam, and other learning cycles
Various Jewish learning programs and their daily selections
This project uses:
MCP SDK for server implementation
Sefaria API for accessing Jewish texts
Python >= 3.10
MCP SDK >= 1.1.1
Sefaria API
MIT License
get a list of references of commentaries for a jewish text
| Name | Required | Description | Default |
|---|---|---|---|
| reference | Yes | the reference of the jewish text, e.g. 'שולחן ערוך אורח חיים סימן א' or 'Genesis 1:1' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only states what the tool does ('get a list of references') without detailing behavioral traits such as whether this is a read-only operation, potential rate limits, authentication needs, or what format the list returns (e.g., structured data, pagination). For a tool with no annotations, this leaves significant gaps in understanding its behavior.
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 extremely concise and front-loaded, consisting of a single sentence that directly states the tool's purpose. There is no wasted language or unnecessary elaboration, making it efficient and easy to parse.
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 lack of annotations and output schema, the description is incomplete for effective use. It doesn't explain what the output looks like (e.g., list format, data structure), behavioral constraints, or how it differs from sibling tools. For a tool with no structured metadata, the description should provide more context to compensate, but it falls short.
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 does not add any parameter-specific information beyond what the input schema provides. The schema has 100% description coverage, with the 'reference' parameter clearly documented with examples. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't compensate with additional semantic context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'get a list of references of commentaries for a jewish text'. It specifies the verb ('get'), resource ('commentaries'), and target ('jewish text'), making it easy to understand what the tool does. However, it doesn't explicitly distinguish this from sibling tools like 'get_text' or 'search_texts', which might also retrieve text-related information.
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 provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_text' or 'search_texts', nor does it specify prerequisites, exclusions, or contextual cues for selecting this tool over others. The user must infer usage from the purpose alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get the daily or weekly learning schedule from Sefaria's calendar
| Name | Required | Description | Default |
|---|---|---|---|
| custom | No | If available, the weekly Haftarah will be returned for the selected custom. | |
| day | No | Day for the date. Must be used with year and month, or API falls back to current date. | |
| diaspora | No | When true, returns weekly Torah reading for diaspora. When false, returns Torah reading for Israel. | |
| month | No | Month for the date. Must be used with year and day, or API falls back to current date. | |
| timezone | No | Timezone name in accordance with IANA Standards. Defaults to client's timezone if not specified. | |
| year | No | Year for the date. Must be used with month and day, or API falls back to current date. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions retrieving schedule data but doesn't describe important behaviors like whether this is a read-only operation, what authentication might be required, rate limits, error conditions, or the format/structure of returned data. The description is too minimal for a tool with 6 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point without unnecessary words. However, it could be slightly more specific about what type of 'learning schedule' is retrieved (e.g., Torah readings, study cycles).
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 tool with 6 parameters and no annotations or output schema, the description is insufficient. It doesn't explain what the returned data looks like, how to interpret results, or provide context about the Sefaria calendar system. The agent would struggle to use this tool effectively without additional information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with all 6 parameters well-documented in the input schema. The description adds no additional parameter information beyond what's already in the schema, so it meets the baseline expectation but doesn't provide extra value.
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 action ('get') and resource ('daily or weekly learning schedule from Sefaria's calendar'), making the purpose understandable. However, it doesn't explicitly differentiate this tool from its siblings (get_commentaries, get_text, search_texts), which all appear to retrieve different types of content from the same system.
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 provides no guidance on when to use this tool versus its siblings or alternatives. It mentions retrieving 'daily or weekly learning schedule' but doesn't clarify when to choose this over other content retrieval tools in the same system.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get a jewish text from the jewish library
| Name | Required | Description | Default |
|---|---|---|---|
| reference | Yes | The reference of the jewish text, e.g. 'שולחן ערוך אורח חיים סימן א' or 'Genesis 1:1' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('get') but doesn't describe traits like whether this is a read-only operation, if it requires authentication, what happens on errors (e.g., invalid reference), or rate limits. The description is minimal and lacks essential behavioral context for a tool with no annotation support.
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 concise and front-loaded in a single sentence ('get a jewish text from the jewish library'), with zero wasted words. It efficiently states the core purpose without unnecessary elaboration, making it easy to parse. However, it's slightly under-specified given the lack of sibling differentiation and behavioral details.
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 complexity (a read operation with one parameter) and lack of annotations and output schema, the description is incomplete. It doesn't cover behavioral aspects, error handling, or output format, leaving gaps for an agent to invoke it correctly. With no structured support, the description should provide more context but falls short.
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 input schema has 100% description coverage, with the 'reference' parameter well-documented in the schema (including examples like 'Genesis 1:1'). The description adds no additional parameter semantics beyond what the schema provides—it doesn't explain reference formats, constraints, or usage. Baseline 3 is appropriate as the schema does the heavy lifting.
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 the tool's purpose ('get a jewish text from the jewish library'), which is clear but vague. It specifies the verb ('get') and resource ('jewish text'), but doesn't differentiate from siblings like 'search_texts' or 'get_commentaries'—it's unclear if this fetches a single text by reference versus searching. The purpose is understandable but lacks specificity for sibling distinction.
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?
No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, exclusions, or compare to sibling tools like 'search_texts' (which might handle broader queries) or 'get_commentaries' (which might retrieve related content). Usage is implied from the name and description alone, with no explicit context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search for jewish texts in the Sefaria library
| Name | Required | Description | Default |
|---|---|---|---|
| filters | No | Filters to apply to the text path in English (Examples: "Shulkhan Arukh", "maimonides", "talmud"). | [] |
| query | Yes | The search query | |
| size | No | Number of results to return. | |
| slop | No | The maximum distance between each query word in the resulting document. 0 means an exact match must be found. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool searches texts but doesn't explain key behaviors: whether it's read-only (implied but not confirmed), how results are returned (e.g., pagination, format), error handling, or performance aspects like rate limits. This leaves significant gaps for an agent to understand operational traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core action ('search') and resource, making it easy to parse quickly. There's no redundancy or fluff, earning its place as a model of conciseness.
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 complexity of a search tool with 4 parameters, no annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects (e.g., result format, pagination), usage guidelines relative to siblings, or output details. While the schema handles parameters well, the overall context for an agent to use this tool effectively is lacking.
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 the schema already documents all parameters (query, filters, size, slop) with clear descriptions. The tool description adds no additional parameter semantics beyond what's in the schema, such as explaining how 'filters' interact with 'query' or providing examples beyond the schema's examples. This meets the baseline for high schema coverage.
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 action ('search') and resource ('jewish texts in the Sefaria library'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this search tool from sibling tools like 'get_text' (which likely retrieves specific texts) or 'get_commentaries' (which might fetch commentary materials), leaving some ambiguity about when to choose one over another.
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 provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_text' (for direct retrieval) or 'get_commentaries' (for commentary-specific queries), nor does it specify use cases like broad searches versus precise lookups. Without this context, users must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool has a clearly distinct purpose with no overlap: get_commentaries retrieves commentary references, get_daily_learnings fetches calendar schedules, get_text obtains specific texts, and search_texts performs library searches. The descriptions are precise, making it easy for an agent to select the correct tool without confusion.
All tool names follow a consistent verb_noun pattern using snake_case (e.g., get_commentaries, search_texts). The naming is uniform across all four tools, with 'get_' and 'search_' as clear action prefixes, enhancing predictability and readability.
With 4 tools, the count is reasonable for a library server, covering core operations like retrieving texts, commentaries, schedules, and searching. It is slightly lean but well-scoped; adding tools for updates or user interactions could enhance it, but it's not incomplete.
The tool set covers essential read-only operations for a Jewish library domain: accessing texts, commentaries, schedules, and searches. Minor gaps exist, such as no update, delete, or user-specific functions (e.g., saving favorites), but agents can work effectively with the provided tools for core queries.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Access Sefaria's library of Jewish texts, commentaries, and learning schedules via MCP
A Model Context Protocol server for Wix AI tools
Sefaria MCP — the free digital library of Jewish texts.
Bible corpus MCP server: scripture, Greek/Hebrew interlinear data, cross-refs, semantic search.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Sivan22/mcp-sefaria-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server