js-translation-helps-proxy
Provides an OpenAI-compatible API that proxies to OpenAI, automatically injecting translation helps tools for scripture and translation notes.
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., "@js-translation-helps-proxyfetch the scripture for John 3:16"
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.
WARNING: This project was vibe coded including this readme. Take the instructions with a grain of salt and do not be fooled by the overly optimistic documentation.
JS Translation Helps Proxy
A production-ready TypeScript MCP proxy for translation-helps with multiple interfaces, built for CloudFlare Workers.
š Table of Contents
Related MCP server: biblebridge-mcp
šÆ Overview
This project provides a production-ready unified proxy service that bridges translation-helps APIs with multiple interface protocols. All 5 interfaces are fully implemented and tested with 98.8% test coverage.
Upstream Service
The upstream translation-helps-mcp service is fully MCP-compliant (as of v6.6.3), providing all tools via the standard MCP protocol at https://translation-helps-mcp.pages.dev/api/mcp. This proxy uses dynamic tool discovery to stay in sync with upstream changes automatically.
⨠Features
5 Complete Interfaces - Core API, MCP HTTP, stdio, OpenAI API, LLM Helper
162 Tests - 98.8% passing (160/162), comprehensive coverage
CloudFlare Workers - Serverless deployment ready
Type-Safe - Full TypeScript with strict mode
Flexible Filtering - Tool filtering, parameter hiding, note filtering
Production Ready - Error handling, logging, caching
Well Documented - Complete docs for all interfaces
šļø Architecture
See ARCHITECTURE.md for detailed system design and component descriptions.
š Project Stats
Lines of Code: ~5,000+
Test Coverage: 98.8% (160/162 tests passing)
Interfaces: 5 complete interfaces
Documentation: 8 comprehensive guides
Examples: Multiple configuration examples
Project Structure
src/
āāā core/ # Interface 1: Core API
āāā mcp-server/ # Interface 2: HTTP MCP
āāā stdio-server/ # Interface 3: stdio MCP
āāā openai-api/ # Interface 4: OpenAI-compatible API
āāā llm-helper/ # Interface 5: OpenAI-compatible TypeScript client
āāā shared/ # Shared utilities
tests/
āāā unit/
āāā integration/
āāā e2e/
dist/
āāā cjs/ # CommonJS build (for require())
āāā esm/ # ESM build (for import)Getting Started
Prerequisites
Node.js >= 20.17.0
npm or yarn
Installation
npm installConfiguration
Copy
.env.exampleto.envFill in your API keys and configuration values
Development
# Build the project (creates both CJS and ESM builds)
npm run build
# Build only CJS
npm run build:cjs
# Build only ESM
npm run build:esm
# Run in development mode (stdio server)
npm run dev
# Run HTTP server in development mode (Wrangler)
npm run dev:http
# Run HTTP server in development mode (Native Node.js with debugging)
npm run dev:node
# Run tests
npm run test
# Lint code
npm run lintDeployment
# Deploy to CloudFlare Workers
npm run deployUsage
Interface 1: Core API (Direct TypeScript/JavaScript)
The core API provides direct programmatic access to translation helps tools. Supports both CommonJS and ESM for maximum compatibility.
ESM (import):
import { TranslationHelpsClient } from 'js-translation-helps-proxy';
const client = new TranslationHelpsClient({
enabledTools: ['fetch_scripture', 'fetch_translation_notes'],
filterBookChapterNotes: true,
});
// Call tools using the generic callTool method
const scripture = await client.callTool('fetch_scripture', {
reference: 'John 3:16',
});CommonJS (require):
const { TranslationHelpsClient } = require('js-translation-helps-proxy');
const client = new TranslationHelpsClient({
enabledTools: ['fetch_scripture', 'fetch_translation_notes'],
filterBookChapterNotes: true,
});Documentation: See ARCHITECTURE.md for complete API reference.
Interface 2: HTTP MCP Server
Web-based MCP server using official Streamable HTTP transport, compatible with MCP Inspector and standard MCP clients.
Start Server:
# Development (Wrangler - CloudFlare Workers local runtime)
npm run dev:http
# Development (Native Node.js - better for debugging)
npm run dev:node
# Production (CloudFlare Workers)
npm run deployEndpoint:
/mcp- Official MCP Streamable HTTP endpoint (POST + GET + DELETE)
Example:
# Initialize session
curl -X POST http://localhost:8787/mcp \
-H "Content-Type: application/json" \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2024-11-05",
"capabilities": {},
"clientInfo": {"name": "test-client", "version": "1.0.0"}
}
}' -i
# List tools (use Mcp-Session-Id from initialize response)
curl -X POST http://localhost:8787/mcp \
-H "Content-Type: application/json" \
-H "Mcp-Session-Id: <session-id>" \
-d '{
"jsonrpc": "2.0",
"id": 2,
"method": "tools/list"
}'MCP Inspector:
# Test with MCP Inspector
npx @modelcontextprotocol/inspector
# Connect to: http://localhost:8787/mcpKey Features:
ā Official MCP Streamable HTTP transport
ā Compatible with MCP Inspector
ā Client-controlled filters (via configuration)
ā Session management with SSE streaming
ā CloudFlare Workers compatible
Documentation: MCP Server Guide
Interface 3: stdio MCP Interface (On-Demand Process)
On-demand process launched by MCP clients (Claude Desktop, Cline, etc.) - not a persistent server.
Key Advantages:
ā No background processes - launched only when the client needs it
ā Automatic lifecycle - terminates when the client disconnects
ā Resource efficient - no idle processes consuming memory
ā stdio transport - communicates via stdin/stdout with the parent MCP client
Unlike Interfaces 2 & 4 (persistent HTTP servers), this is a process that the MCP client spawns on-demand.
Quick Start:
# Run from npm (recommended)
npx js-translation-helps-proxy --help
# Or directly from GitHub:
# npx github:JEdward7777/js-translation-helps-proxy --help
# List available tools
npx js-translation-helps-proxy --list-tools
# Launch the process (for manual testing - normally the MCP client launches it)
npx js-translation-helps-proxyNote: In normal use, your MCP client (Claude Desktop, Cline) automatically launches this process when needed. You don't need to start or manage it manually.
Configuration Options:
# Enable specific tools only
npx js-translation-helps-proxy --enabled-tools "fetch_scripture,fetch_translation_notes"
# Hide parameters from tool schemas
npx js-translation-helps-proxy --hide-params "language,organization"
# Filter book/chapter notes
npx js-translation-helps-proxy --filter-book-chapter-notes
# Set log level
npx js-translation-helps-proxy --log-level debugMCP Client Setup:
For Claude Desktop, add to your config file:
{
"mcpServers": {
"translation-helps": {
"command": "npx",
"args": ["js-translation-helps-proxy"]
}
}
}Or to use the latest GitHub version:
{
"mcpServers": {
"translation-helps": {
"command": "npx",
"args": ["github:JEdward7777/js-translation-helps-proxy"]
}
}
}Key Features:
ā On-demand process - no persistent server running
ā Client-controlled filters - configure per MCP client
ā Works with Claude Desktop, Cline, etc. - any MCP client supporting stdio
ā stdio transport - standard input/output communication
ā Easy npx deployment - client launches via npx when needed
Documentation: stdio Server Guide | Example Configs
Interface 4: OpenAI-Compatible API
REST API that proxies to OpenAI with automatic Translation Helps tool injection and baked-in filters (see Interface 5 for TypeScript equivalent).
Start Server:
# Development (Wrangler - CloudFlare Workers local runtime)
npm run dev:http
# Development (Native Node.js - better for debugging)
npm run dev:node
# Production (CloudFlare Workers)
npm run deployEndpoints:
POST /v1/chat/completions- Chat completions with tool executionGET /v1/models- List available OpenAI models (proxied)GET /v1/tools- List available toolsGET /health- Health check
Example with OpenAI Client:
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:8787/v1",
api_key="sk-YOUR-OPENAI-KEY" # Your actual OpenAI API key
)
response = client.chat.completions.create(
model="gpt-4o-mini", # Use any OpenAI model
messages=[
{"role": "user", "content": "Fetch scripture for John 3:16"}
]
)
print(response.choices[0].message.content)Example with curl:
curl -X POST http://localhost:8787/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer sk-YOUR-OPENAI-KEY" \
-d '{
"model": "gpt-4o-mini",
"messages": [
{"role": "user", "content": "Fetch John 3:16"}
]
}'Key Features:
ā Proxies to OpenAI: Uses real OpenAI models and API
ā Automatic tool injection: Translation Helps tools added automatically
ā Baked-in filters:
language=en,organization=unfoldingWordā Iterative tool execution: Handles tool calling loops
ā Supports n > 1 and structured outputs
ā CloudFlare Workers compatible
Documentation: OpenAI API Guide
Interface 5: OpenAI-Compatible TypeScript Client
Drop-in replacement for OpenAI client as a TypeScript class with Translation Helps tools automatically integrated. Unlike Interface 4 (HTTP/REST API), this is a direct TypeScript client with no network serialization overhead. Both interfaces share the same OpenAI integration logic (see comparison table). Supports both CommonJS and ESM for maximum compatibility.
Quick Start (ESM):
import { LLMHelper } from 'js-translation-helps-proxy/llm-helper';
// Drop-in replacement for OpenAI client
const helper = new LLMHelper({
apiKey: process.env.OPENAI_API_KEY!,
});
// Use the same API as OpenAI
const response = await helper.chat.completions.create({
model: 'gpt-4o-mini',
messages: [{ role: 'user', content: 'What does John 3:16 say?' }],
n: 2 // Generate 2 completions
});
// Returns full OpenAI ChatCompletion response
console.log(response.choices[0].message.content);
console.log(response.choices[1].message.content); // When n > 1Interchangeability with OpenAI:
import { LLMHelper } from 'js-translation-helps-proxy/llm-helper';
import OpenAI from 'openai';
// Can use either client with the same code!
const client: OpenAI | LLMHelper = useTranslationHelps
? new LLMHelper({ apiKey })
: new OpenAI({ apiKey });
// Same API works for both
const response = await client.chat.completions.create({
model: 'gpt-4o-mini',
messages: [{ role: 'user', content: 'Hello!' }]
});Quick Start (CommonJS):
const { LLMHelper } = require('js-translation-helps-proxy/llm-helper');
const helper = new LLMHelper({
apiKey: process.env.OPENAI_API_KEY,
});Key Features:
ā Drop-in OpenAI replacement: Implements
OpenAI.chat.completions.create()interfaceā Full response compatibility: Returns complete OpenAI
ChatCompletionobjectsā Shares logic with Interface 4: Same OpenAI SDK integration
ā Supports all OpenAI parameters: Including
n > 1,temperature,response_formatā Fixes
n > 1bug: All choices preserved in responseā Automatic tool execution: Translation Helps tools work automatically
ā Baked-in filters:
language=en,organization=unfoldingWordā Type-safe: Full TypeScript support
Documentation: LLM Helper Guide | Examples
Interface Comparison
Feature | Interface 1 (Core) | Interface 2 (MCP HTTP) | Interface 3 (stdio) | Interface 4 (OpenAI REST API) | Interface 5 (OpenAI TypeScript Client) |
Transport | Direct API | HTTP | stdio | HTTP/REST | TypeScript API |
Backend | Direct | Direct | Direct | Proxies to OpenAI | Proxies to OpenAI |
Network | N/A | Required | N/A | Required | Not required |
API Key | Not required | Not required | Not required | Required (OpenAI) | Required (OpenAI) |
Models | N/A | N/A | N/A | Any OpenAI model | Any OpenAI model |
Filters | Configurable | Client-controlled | Client-controlled | Baked-in | Baked-in |
Use Case | TypeScript apps | Web services | Desktop apps | LLM integrations (HTTP) | LLM integrations (TypeScript) |
Deployment | Library | CloudFlare Workers | On-demand process | CloudFlare Workers | Library |
Tool Execution | Manual | Manual | Manual | Automatic | Automatic |
Lifecycle | N/A | Persistent server | Launched on-demand | Persistent server | N/A |
Choose Interface 2 or 3 when you need client-controlled filters (see MCP Server or stdio Server). Choose Interface 3 specifically when you want no background processes (on-demand launching). Choose Interface 4 or 5 when you need OpenAI integration with automatic tool execution (REST API vs TypeScript).
Quick Start Guide
For Desktop Apps (Claude Desktop, Cline)
Use Interface 3 (stdio):
# Run from npm (recommended)
npx js-translation-helps-proxy
# Or directly from GitHub for latest development version:
# npx github:JEdward7777/js-translation-helps-proxyFor Web Services / APIs
Use Interface 2 (MCP HTTP):
# Using Wrangler (CloudFlare Workers runtime)
npm run dev:http
# Access at http://localhost:8787/mcp/*
# Using Native Node.js (better for debugging)
npm run dev:node
# Access at http://localhost:8787/mcp/*For LLM Integrations (OpenAI-compatible)
Use Interface 4 (OpenAI API):
# Using Wrangler (CloudFlare Workers runtime)
npm run dev:http
# Access at http://localhost:8787/v1/*
# Using Native Node.js (better for debugging)
npm run dev:node
# Access at http://localhost:8787/v1/*For TypeScript/JavaScript Projects
Use Interface 1 (Core API) - supports both ESM and CommonJS:
ESM:
import { TranslationHelpsClient } from 'js-translation-helps-proxy';CommonJS:
const { TranslationHelpsClient } = require('js-translation-helps-proxy');For LLM Integration in TypeScript/JavaScript
Use Interface 5 (LLM Helper) - supports both ESM and CommonJS:
ESM:
import { LLMHelper } from 'js-translation-helps-proxy/llm-helper';
const helper = new LLMHelper({
apiKey: process.env.OPENAI_API_KEY!,
});
const response = await helper.chat.completions.create({
model: 'gpt-4o-mini',
messages: [{ role: 'user', content: 'Fetch John 3:16' }]
});CommonJS:
const { LLMHelper } = require('js-translation-helps-proxy/llm-helper');š Documentation
Documentation Index - Complete documentation hub
Architecture Guide - System architecture
Testing Guide - Test coverage and strategy
Deployment Guide - CloudFlare Workers deployment
Contributing Guide - How to contribute
Interface Documentation
MCP HTTP Server - Interface 2 documentation
stdio Server - Interface 3 documentation
OpenAI API - Interface 4 documentation
LLM Helper - Interface 5 documentation
š§Ŗ Testing
The project has comprehensive test coverage:
# Run all tests
npm test
# Run specific test suites
npm run test:unit # 65 unit tests
npm run test:integration # 80 integration tests
npm run test:e2e # 8 E2E testsTest Results:
ā 160 tests passing (98.8%)
āļø 2 tests skipped (require API keys)
See TESTING.md for detailed test documentation.
š Deployment
CloudFlare Workers
# Build and deploy
npm run build
npm run deploySee DEPLOYMENT.md for complete deployment guide.
Local Development
# Start HTTP server (Wrangler - CloudFlare Workers runtime)
npm run dev:http
# Start HTTP server (Native Node.js - better for debugging)
npm run dev:node
# Start stdio server
npm run devVSCode Debugging
The project includes VSCode launch configurations for debugging:
Debug HTTP Server - Native Node.js (Interfaces 2 & 4) - Debug MCP HTTP and OpenAI API servers
Debug HTTP Server - Built (Interfaces 2 & 4) - Debug compiled HTTP servers
Debug stdio Server (Interface 3) - Debug stdio MCP server (uses stdin/stdout, not HTTP)
Debug Current Test File - Debug the currently open test file
To use:
Open the file you want to debug
Set breakpoints by clicking in the gutter
Press
F5or go to Run > Start DebuggingSelect the appropriate debug configuration
Important:
Interface 3 (stdio) is an on-demand process launched by the MCP client, communicating via stdin/stdout (NOT HTTP/REST)
Interfaces 2 & 4 are persistent HTTP/REST servers accessible at
http://localhost:8787Interface 3 has no background process - it's launched when needed and terminates when done
The server will start with
LOG_LEVEL=debugfor detailed logging
š¤ Contributing
We welcome contributions! Please see CONTRIBUTING.md for guidelines.
Quick Start for Contributors
Fork and clone the repository
Install dependencies:
npm installCreate a feature branch
Make your changes with tests
Run checks:
npm run lint && npm testSubmit a pull request
š License
MIT - See LICENSE file for details.
š Acknowledgments
Translation Helps MCP - Fully MCP-compliant upstream server (v6.6.3+)
Model Context Protocol - MCP specification
CloudFlare Workers - Serverless platform
All Contributors - Thank you!
š Support
Documentation: docs/INDEX.md
Issues: GitHub Issues
Discussions: GitHub Discussions
Version: 0.2.0 | Last Updated: 2025-11-23 | Status: Production Ready ā
Dynamic Tool Discovery
This proxy uses dynamic tool discovery from the upstream MCP server. Tool schemas are fetched at runtime, ensuring we're always in sync with the upstream service. No manual updates needed when upstream adds/removes tools!
Available Tools
8 toolsfetch_scriptureA
Fetch Bible scripture text. Use reference for specific passages, or search/filter for discovery. ALWAYS use format: "md" for best results.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Keyword filter with stemming (e.g., "love" matches love, loves, loved). Requires reference OR specific resource. | |
| format | No | Output format: ALWAYS use "md" (markdown with YAML frontmatter, LLM-friendly) | md |
| search | No | Semantic search query to find passages about a topic | |
| language | No | en | |
| resource | No | Translation(s): "all", "ult", "ust", etc. | all |
| reference | No | Bible reference (e.g., 'John 3:16'). Required unless using search or filter. | |
| testament | No | Limit filter/search to Old Testament (ot) or New Testament (nt) | |
| organization | No | unfoldingWord |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It adds the directive 'ALWAYS use format: "md" for best results', which is useful behavioral guidance, but it does not disclose return structure, rate limits, or potential side effects. Since this is a fetch operation, the lack of explicit read-only disclosure is mitigated but not fully addressed.
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, front-loaded with the primary purpose, and every word earns its place. It is concise without sacrificing clarity.
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?
With 8 parameters and no output schema, the description leaves out explanations of resource, testament, organization, and language. It does cover the main usage modes, but relies heavily on the schema for full context, making it minimally sufficient rather than complete.
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 75%, and the description adds meaningful context by explaining when to use reference versus search/filter, and strongly recommends format 'md'. This clarifies parameter relationships beyond the schema's individual field descriptions.
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 'Fetch Bible scripture text' with a specific verb and resource, and clearly distinguishes this tool from sibling translation resources. It also differentiates the discovery modes (reference vs search/filter), making the scope 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 provides guidance on when to use reference versus search/filter, but does not explicitly mention alternatives or when not to use this tool relative to siblings like search_biblical_resources. Usage is implied rather than explicitly contrasted with other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
fetch_translation_academyC
Get Translation Academy articles, or use filter to search across all modules.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Stemmed regex filter to search all modules (e.g., "metaphor" matches "metaphor", "metaphors", "metaphorical") | |
| category | No | Limit filter to category: translate, checking, process, or intro | |
| language | No | en | |
| moduleId | No | Academy module ID (e.g., "figs-metaphor") - optional when using filter | |
| organization | No | unfoldingWord |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears the full burden of behavioral disclosure. It states the tool 'gets' or 'searches' which implies read-only behavior, but it doesn't disclose details about response structure, pagination, rate limits, or any side effects. The schema adds some filter behavior (stemmed regex) but the description itself is thin on behavioral 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 concise sentence, front-loaded with the main action. It avoids unnecessary words. However, it might be too terse given the tool's complexity, but for conciseness it earns a good score.
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?
With 5 parameters, no annotations, and no output schema, the description is insufficiently complete. It does not explain what the returned articles look like, how language/organization affect results, or provide examples of usage. For a tool with this complexity, the description should offer more context to enable 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 coverage is 60%, with descriptions for filter, category, and moduleId. The description adds a small amount of semantic value by explaining that the filter searches across all modules, which parallels the schema's description. However, it does not clarify language or organization parameters, and the added value over the schema is minimal. Given moderate schema coverage, a 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 clearly identifies the tool's purpose: retrieving Translation Academy articles. It also mentions an alternative mode (using filter to search across modules), which adds specificity. It distinguishes itself from siblings like fetch_translation_notes and fetch_translation_questions by explicitly naming the resource type (Translation Academy), though it doesn't contrast directly.
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 explicit guidance on when to use this tool versus alternatives. It does not mention siblings or exclusions. The only implicit hint is that it's for Translation Academy content, but there is no when-to-use/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.
fetch_translation_notesA
Fetch translation notes for a specific Bible reference, or use filter param to search across all notes.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Stemmed regex filter to search all notes (e.g., "metaphor" matches "metaphor", "metaphors", "metaphorical") | |
| format | No | Output format: md (markdown with YAML frontmatter, LLM-friendly), json, or text | md |
| search | No | Optional: Filter notes by search query | |
| language | No | en | |
| reference | No | Bible reference (optional when using filter) | |
| testament | No | Limit filter to Old Testament (ot) or New Testament (nt) | |
| organization | No | unfoldingWord |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Fetch' (implying read-only) and describes two lookup modes, but does not explain the output format differences, default markdown behavior, or any limitations. The description adds minimal context beyond what the tool name already suggests.
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?
A single, well-structured sentence that states the core purpose and an alternative usage mode. Every word contributes meaning, and the filter parameter is mentioned to clarify a non-obvious usage.
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 7 parameters, no output schema, and no annotations, the description is functional but sparse. It relies heavily on the schema to convey parameter details and does not mention output formats or default values, which are important for a fetch tool. The description is adequate for straightforward use but lacks depth for edge cases.
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 71%, with good descriptions for filter, format, search, reference, and testament, but language and organization are undocumented. The description highlights the filter parameter's role in searching, aligning with the schema, but does not compensate for the missing parameter descriptions. Overall, the schema does most of 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 clearly states the tool fetches translation notes, either for a specific Bible reference or via a filter search across all notes. This distinguishes it from sibling tools like fetch_translation_questions and fetch_translation_word by naming the resource type and its unique search mode.
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 implies two usage modes (reference lookup or filter search) but does not explicitly mention which sibling tool to use instead for other resource types. The context is evident from the tool name, but there are no explicit alternatives or 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.
fetch_translation_questionsA
Fetch translation questions for a specific Bible reference, or use filter param to search across all questions.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Stemmed regex filter to search all questions (e.g., "faith" matches "faith", "faithful", "faithfulness") | |
| search | No | Optional: Filter questions by search query | |
| language | No | en | |
| reference | No | Bible reference (optional when using filter) | |
| testament | No | Limit filter to Old Testament (ot) or New Testament (nt) | |
| organization | No | unfoldingWord |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only mentions the two input modes but leaves critical ambiguities: what happens if both reference and filter are given, what happens when no parameters are supplied (since all are optional), and what the return structure looks like. These omissions limit 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 a single, concise sentence that front-loads the primary action and clearly contrasts the two usage modes. Every word contributes meaning, with no redundancy or 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?
Given the tool has 6 optional parameters, no output schema, and no annotations, the description is too brief to be considered complete. It fails to explain parameter interactions, default behaviors, ambiguity when both reference and filter are used, or the shape of the returned data, leaving an AI agent under-informed for proper 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?
The schema already covers 67% of parameters with descriptions for filter, search, reference, and testament. The description adds value by explaining the relationship between reference (specific Bible reference) and filter (search across all questions), but it does not clarify the remaining undocumented parameters like language and organization. Baseline for moderate coverage is 3.
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 the specific verb 'Fetch' with the clear resource 'translation questions', and explicitly defines two modes: fetching by Bible reference or searching via the filter param. This clearly distinguishes it from sibling tools like fetch_translation_notes and fetch_translation_word, which target different resource types.
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 clearly indicates the two primary use cases: retrieving questions for a specific Bible reference, or using the filter param to search across all questions. However, it does not explicitly name sibling tools or provide when-not-to-use guidance, such as when to prefer fetch_translation_notes over this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
fetch_translation_wordA
Get Translation Word articles including key biblical terms, names of people, names of places, and other important words. The library contains thousands of articles. Use filter param to search across all words.
| Name | Required | Description | Default |
|---|---|---|---|
| term | No | The term, name, or word to look up (optional when using filter) | |
| filter | No | Stemmed regex filter to search all words (e.g., "love" matches "love", "loving", "beloved") | |
| category | No | Limit filter to word category: kt, names, or other | |
| language | No | en | |
| organization | No | unfoldingWord |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries full burden. It adds context about the library's size ('thousands of articles') but doesn't disclose behavior such as whether it returns a list or single item, nor any read-only/auth implications beyond the verb 'Get'.
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?
Two concise sentences: the first states the tool's purpose and scope, the second provides a key usage tip. No fluff, 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?
For a straightforward lookup tool with all-optional parameters and no output schema, the description covers the primary use case and the main search parameter. It doesn't detail return format, but that's not expected without an output schema. Minor gaps like language/organization are covered by 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 schema already describes term, filter, and category. The description adds a practical hint to use filter for searching, but doesn't explain the interaction between term and filter or the remaining language/organization parameters. With 60% schema coverage, this is adequate but not highly informative.
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 phrase 'Get Translation Word articles' and enumerates content types (key biblical terms, names, places, other words), clearly distinguishing it from sibling tools like fetch_translation_notes or fetch_scripture.
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 gives an explicit directive to use the filter parameter for searching across all words, and the description implies that this tool is for word/article lookups. However, it doesn't explicitly contrast with alternatives or state when not to use it, so not a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
fetch_translation_word_linksB
Get translation word links for a Bible reference, or use filter to search across all word links.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Stemmed regex filter to search all word links (e.g., "love" matches "love", "loved", "beloved") | |
| category | No | Limit filter to word category: kt, names, or other | |
| language | No | en | |
| reference | No | Bible reference (optional when using filter) | |
| testament | No | Limit filter to Old Testament (ot) or New Testament (nt) | |
| organization | No | unfoldingWord |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that the tool 'gets' or 'searches,' implying read-only behavior, but does not describe what 'word links' are, the return format, pagination, or effects of invalid or missing parameters. This is a significant transparency gap even for a read operation.
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 sentence with no filler, front-loading the core action ('Get translation word links') and then adding the alternative filter mode. Every word earns its place; it is excellently concise.
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 leaves many gaps: it does not define 'translation word links,' clarify the relationship between reference and filter, mention default values for language/organization, or explain what the output looks like. With 6 optional parameters and no output schema or annotations, the description is not sufficiently complete for effective tool 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 67% (filter, category, reference, testament have descriptions; language and organization rely on defaults). The description adds minimal extra parameter meaningāonly that 'filter' enables a broader search. It does not explain language, organization, or the interplay between reference and filter, but the schema partially covers this.
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 ('Get') and resource ('translation word links') with two clear modes: for a Bible reference or via filter. This distinguishes it from sibling tools like fetch_translation_word (singular) and search_biblical_resources, though it does not explicitly name alternatives. The resource is specific enough to convey its unique purpose.
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 implies two usage scenarios: use it with a reference to get links, or use a filter to search across all word links. However, it provides no explicit guidance on when to prefer this over fetch_translation_word or search_biblical_resources, and does not mention exclusions or preconditions. The usage context is implied but not fully clarified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_system_promptA
Get the complete system prompt and constraints for full transparency about AI behavior
| Name | Required | Description | Default |
|---|---|---|---|
| includeImplementationDetails | No | Include implementation details and validation functions |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. 'Get' implies a read operation, but the description does not state whether this action is safe, non-mutating, or requires any special permissions. It also doesn't disclose potential side effects or what happens if the optional parameter is omitted. The transparency-focused wording does not compensate for these 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 a single, compact sentence that directly states the tool's purpose with minimal waste. It is appropriately sized and 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 tool is simple with one optional parameter and no output schema. The description clearly indicates what the tool returns (system prompt and constraints), but it lacks usage guidance and behavioral disclosure. Given the simplicity, the description is adequate but not fully complete, especially due to missing annotations.
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 full coverage (100%) for the single parameter 'includeImplementationDetails', which includes its own description. The tool description adds no additional meaning about the parameter beyond the schema, so a baseline score of 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 clearly states the tool's function: 'Get the complete system prompt and constraints'. It uses a specific verb and resource, and the purpose is distinct from sibling tools which focus on biblical resources and translations.
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 'for full transparency about AI behavior' implies a usage context, but there is no explicit guidance on when to use this tool versus alternatives, no when-not-to-use cases, and no mention of prerequisites. The sibling tools are clearly different in domain, so the purpose is understandable, but explicit guidelines are missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_biblical_resourcesA
Search biblical translation resources (scripture, notes, questions, words) using BM25 scoring algorithm
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | Yes | Search query | |
| language | No | en | |
| reference | No | Optional Bible reference filter | |
| includeHelps | No | ||
| organization | No | unfoldingWord |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the burden of behavioral disclosure. It adds useful context by naming the BM25 scoring algorithm and the resource types searched, but it does not explicitly state that the operation is read-only or describe any side effects, rate limits, or permission requirements. For a simple search tool this is adequate but not thorough.
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, front-loaded sentence of 12 words. It contains no repetition, filler, or unnecessary details. Every word contributes to conveying the purpose and key behavioral attribute (BM25), making it highly efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 6 parameters, no annotations, and no output schema, the description is too sparse. It does not mention return format, pagination, parameter usage, or relationship to sibling fetch tools. The brief description covers only the core purpose, leaving the agent without adequate context to invoke the tool correctly in varied scenarios.
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 33% (query and reference have descriptions). The description itself does not explain the remaining parameters (limit, language, includeHelps, organization) and only mentions resource types, which are not directly tied to parameters. This leaves the agent to guess meanings of several important fields, so the description fails to compensate for the low 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 tool performs a search over biblical translation resources (scripture, notes, questions, words) using BM25 scoring. This verb+resource combination is specific and distinguishes it from sibling fetch_* tools, which retrieve specific resources by identifier rather than searching across them.
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 implies usage as a discovery/search mechanism but does not explicitly state when to use it versus the fetch_* siblings. There is no mention of alternatives or exclusions, so the guidance remains implicit rather than spelled out. The tool name itself signals a search role, but the description alone lacks explicit direction.
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.
8 tool updates
v0.2.1- First observed
fetch_scripture - First observed
fetch_translation_academy - First observed
fetch_translation_notes - First observed
fetch_translation_questions - First observed
fetch_translation_word - First observed
fetch_translation_word_links - First observed
get_system_prompt - First observed
search_biblical_resources
TDQS
Most tools target distinct resource types (scripture, notes, questions, words, word links, academy), making them easy to differentiate. However, the fetch tools' filter parameters overlap with the dedicated search tool, creating minor ambiguity about which tool to use for discovery.
The majority follow a consistent 'fetch_<resource>' pattern (fetch_translation_notes, fetch_scripture, etc.), but 'get_system_prompt' and 'search_biblical_resources' break the pattern, mixing 'get' and 'search' verbs with 'fetch'.
With 8 tools, the count is well within the ideal range for a domain-specific proxy. Each tool represents a distinct core capability, and none feel redundant or excessive.
The set covers all major translation help resourcesāscripture, notes, questions, words, word links, and academy articlesāplus a cross-resource search tool. This provides a comprehensive read-only surface with no obvious gaps for the stated purpose.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Bible MCP ā wraps the Bible API (free, no auth)
- QuallaaOAuthcom.quallaa
Talk to your public-facing AI from any MCP client ā Claude, ChatGPT, Cursor, Cline, Windsurf.
Human-input bridge for AI agents with voice-first answer links, MCP tools, and HTTP APIs.
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
Related MCP Servers
- FlicenseAqualityDmaintenanceEnables AI assistants to retrieve Bible passages from multiple translations (ESV, NIV, KJV, NASB, NKJV, NLT, AMP, MSG). Supports querying single or multiple passages and provides both MCP protocol integration and REST API endpoints.17-
- AlicenseNot gradedqualityNot gradedmaintenanceProvides structured access to Scripture through the BibleBridge API, enabling semantic search, contextual verse retrieval, and cross-reference analysis. It supports natural language reference normalization and comparative theological exploration across different passages.1-
- FlicenseNot gradedqualityDmaintenanceA command-line interface application enabling interactive chat with AI models via the Anthropic API. It supports document retrieval, command-based prompts, and extensible tool integrations through the MCP architecture.-
- FlicenseBqualityDmaintenanceEnables interactive chat with AI models and document retrieval via the Anthropic API, supporting command-based prompts and MCP tool integrations.2-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/JEdward7777/js-translation-helps-proxy'
If you have feedback or need assistance with the MCP directory API, please join our Discord server