Skip to main content
Glama
JEdward7777

js-translation-helps-proxy

by JEdward7777

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

Tests Coverage TypeScript License CloudFlare Workers

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 install

Configuration

  1. Copy .env.example to .env

  2. Fill 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 lint

Deployment

# Deploy to CloudFlare Workers
npm run deploy

Usage

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 deploy

Endpoint:

  • /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/mcp

Key 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-proxy

Note: 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 debug

MCP 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 deploy

Endpoints:

  • POST /v1/chat/completions - Chat completions with tool execution

  • GET /v1/models - List available OpenAI models (proxied)

  • GET /v1/tools - List available tools

  • GET /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 > 1

Interchangeability 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 ChatCompletion objects

  • āœ… Shares logic with Interface 4: Same OpenAI SDK integration

  • āœ… Supports all OpenAI parameters: Including n > 1, temperature, response_format

  • āœ… Fixes n > 1 bug: 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-proxy

For 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

Interface 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 tests

Test 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 deploy

See 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 dev

VSCode Debugging

The project includes VSCode launch configurations for debugging:

  1. Debug HTTP Server - Native Node.js (Interfaces 2 & 4) - Debug MCP HTTP and OpenAI API servers

  2. Debug HTTP Server - Built (Interfaces 2 & 4) - Debug compiled HTTP servers

  3. Debug stdio Server (Interface 3) - Debug stdio MCP server (uses stdin/stdout, not HTTP)

  4. Debug Current Test File - Debug the currently open test file

To use:

  1. Open the file you want to debug

  2. Set breakpoints by clicking in the gutter

  3. Press F5 or go to Run > Start Debugging

  4. Select 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:8787

  • Interface 3 has no background process - it's launched when needed and terminates when done

  • The server will start with LOG_LEVEL=debug for detailed logging

šŸ¤ Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

Quick Start for Contributors

  1. Fork and clone the repository

  2. Install dependencies: npm install

  3. Create a feature branch

  4. Make your changes with tests

  5. Run checks: npm run lint && npm test

  6. Submit 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


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 tools
fetch_scriptureA

Fetch Bible scripture text. Use reference for specific passages, or search/filter for discovery. ALWAYS use format: "md" for best results.

ParametersJSON Schema
NameRequiredDescriptionDefault
filterNoKeyword filter with stemming (e.g., "love" matches love, loves, loved). Requires reference OR specific resource.
formatNoOutput format: ALWAYS use "md" (markdown with YAML frontmatter, LLM-friendly)md
searchNoSemantic search query to find passages about a topic
languageNoen
resourceNoTranslation(s): "all", "ult", "ust", etc.all
referenceNoBible reference (e.g., 'John 3:16'). Required unless using search or filter.
testamentNoLimit filter/search to Old Testament (ot) or New Testament (nt)
organizationNounfoldingWord

TDQS

A3.9/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
filterNoStemmed regex filter to search all modules (e.g., "metaphor" matches "metaphor", "metaphors", "metaphorical")
categoryNoLimit filter to category: translate, checking, process, or intro
languageNoen
moduleIdNoAcademy module ID (e.g., "figs-metaphor") - optional when using filter
organizationNounfoldingWord

TDQS

C2.9/5.0
Behavior2/5

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.

Conciseness4/5

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.

Completeness2/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines2/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
filterNoStemmed regex filter to search all notes (e.g., "metaphor" matches "metaphor", "metaphors", "metaphorical")
formatNoOutput format: md (markdown with YAML frontmatter, LLM-friendly), json, or textmd
searchNoOptional: Filter notes by search query
languageNoen
referenceNoBible reference (optional when using filter)
testamentNoLimit filter to Old Testament (ot) or New Testament (nt)
organizationNounfoldingWord

TDQS

A3.5/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
filterNoStemmed regex filter to search all questions (e.g., "faith" matches "faith", "faithful", "faithfulness")
searchNoOptional: Filter questions by search query
languageNoen
referenceNoBible reference (optional when using filter)
testamentNoLimit filter to Old Testament (ot) or New Testament (nt)
organizationNounfoldingWord

TDQS

A3.6/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness2/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
termNoThe term, name, or word to look up (optional when using filter)
filterNoStemmed regex filter to search all words (e.g., "love" matches "love", "loving", "beloved")
categoryNoLimit filter to word category: kt, names, or other
languageNoen
organizationNounfoldingWord

TDQS

A4/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

get_system_promptA

Get the complete system prompt and constraints for full transparency about AI behavior

ParametersJSON Schema
NameRequiredDescriptionDefault
includeImplementationDetailsNoInclude implementation details and validation functions

TDQS

A3.5/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNo
queryYesSearch query
languageNoen
referenceNoOptional Bible reference filter
includeHelpsNo
organizationNounfoldingWord

TDQS

A3.5/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness2/5

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.

Parameters2/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

  1. 8 tool updatesv0.2.1
    • First observedfetch_scripture
    • First observedfetch_translation_academy
    • First observedfetch_translation_notes
    • First observedfetch_translation_questions
    • First observedfetch_translation_word
    • First observedfetch_translation_word_links
    • First observedget_system_prompt
    • First observedsearch_biblical_resources

TDQS

A3.7/5.0
Disambiguation4/5

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.

Naming Consistency4/5

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'.

Tool Count5/5

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.

Completeness5/5

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

ActivityInactive
ResponsivenessNo issues

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

Related MCP Servers

  • F
    license
    A
    quality
    D
    maintenance
    Enables 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.
    1
    7
    -
  • A
    license
    Not graded
    quality
    Not graded
    maintenance
    Provides 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
    -
  • F
    license
    Not graded
    quality
    D
    maintenance
    A 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.
    -

Latest Blog Posts

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