Provides access to Jewish texts from the Sefaria library, enabling retrieval of specific texts by reference and their associated commentaries.
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., "@Sefaria Jewish Library MCP Server get the commentaries for 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
Related MCP server: Sefaria Jewish Library MCP Server
Requires Python 3.10 or higher.
To install Sefaria Jewish Library for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install mcp-sefaria-server --client claudegit 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",
"C:/dev/mcp-sefaria-server",
"run",
"sefaria_jewish_library"
],
"env": {
"PYTHONIOENCODING": "utf-8"
}
}
}
}The 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: "משנה ברכות פרק א משנה א"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 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.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
get_commentariesget_textScored across 2 tools
The two tools have clearly distinct purposes: get_commentaries retrieves commentary references for a text, while get_text retrieves the text itself. There is no overlap or ambiguity between these operations, making it easy for an agent to select the correct tool based on the need.
Both tools follow a consistent verb_noun naming pattern (get_commentaries and get_text), using the same verb 'get' and descriptive nouns. This uniformity makes the tool set predictable and easy to understand at a glance.
With only 2 tools, the server feels under-scoped for a library domain that typically involves more operations like search, update, or categorization. While the tools cover basic retrieval, the count is too low to support comprehensive interactions with a Jewish library, limiting agent capabilities.
The tool set is severely incomplete for a library server, lacking essential operations such as search, filtering, creation, or management of texts and commentaries. Agents will face dead ends when trying to perform common library tasks beyond simple retrieval, leading to potential failures.
Access Sefaria's library of Jewish texts, commentaries, and learning schedules via MCP
Sefaria MCP — the free digital library of Jewish texts.
Code intelligence for LLMs. Analyze, search, and retrieve code from any public git repository.
Enable Large Language Model clients to interact seamlessly with any MediaWiki wiki. Perform action…
