Instructions

{
  "passage": "John 3:16",
  "version": "NIV"
}

{
  "passage": "Mark 2:1-12",
  "version": "ESV"
}

{
  "passage": "Psalm 23",
  "version": "KJV"
}

{
  "passage": "John 3:16; Romans 8:28; Philippians 4:13",
  "version": "ESV"
}

Implementation Reference

• mcp_bible/features/get_passage/tool.py:29-54 (handler)

  The async get_passage function implementing the core tool logic: validates input with GetPassageRequest, fetches passage from BibleService, handles errors, and returns result.

  async def get_passage(passage: str, version: str = "ESV") -> Dict[str, Any]:
      """Get a Bible passage with comprehensive documentation loaded from instructions.md"""
      try:
          logger.info(f"MCP tool called: get_passage(passage='{passage}', version='{version}')")
  
          # Create and validate request
          request = GetPassageRequest(
              passage=passage,
              version=version
          )
  
          # Call bible service
          result = await bible_service.fetch_passage(
              passage=request.passage,
              version=request.version
          )
  
          logger.info(f"Passage retrieval completed: {passage} ({version})")
          return result
  
      except ValueError as e:
          logger.warning(f"Passage validation error: {e}")
          raise
      except Exception as e:
          logger.error(f"Passage retrieval error: {e}")
          raise

• mcp_bible/features/get_passage/models.py:9-24 (schema)

  Pydantic schemas: GetPassageRequest (input with passage and version fields) and GetPassageResponse (output with success, text, error).

  class GetPassageRequest(BaseModel):
      """Request model for getting a Bible passage"""
      passage: str = Field(description="Bible reference(s) (e.g., 'John 3:16', 'Romans 8', or 'John 3:16; Romans 8:28')", min_length=1)
      version: str = Field(
          default="ESV",
          description="Bible translation version (e.g., 'ESV', 'NIV', 'KJV')"
      )
  
  
  class GetPassageResponse(BaseModel):
      """Response model for Bible passage retrieval"""
      success: bool = Field(description="Whether the request was successful")
      passage: str = Field(description="The requested Bible reference")
      version: str = Field(description="The Bible version used")
      text: Optional[str] = Field(default=None, description="The passage text")
      error: Optional[str] = Field(default=None, description="Error message if request failed")

• mcp_bible/features/get_passage/tool.py:19-28 (registration)

  The register_tool function that defines and registers the get_passage MCP tool using @mcp.tool() decorator, injecting docstring and defining the handler.

  def register_tool(mcp: FastMCP, bible_service: BibleService) -> None:
      """
      Register the get_passage tool with the MCP server
  
      Args:
          mcp: FastMCP server instance
          bible_service: BibleService instance for Bible operations
      """
      @mcp.tool()
      @inject_docstring(lambda: load_instruction("instructions.md", __file__))

• mcp_bible/service.py:46-88 (registration)

  Dynamic registration in BibleMCPService.register_mcp_tools: discovers 'get_passage' feature, imports its tool.py, and calls register_tool(mcp, bible_service).

  def register_mcp_tools(self, mcp: FastMCP) -> None:
      """
      Register MCP tools for this service using automatic feature discovery
  
      Discovers and registers tools from all feature modules that have a tool.py
      with a register_tool() function.
      """
      logger.info("Discovering and registering MCP tools from features...")
  
      # Get the features package path
      features_package = "mcp_bible.features"
      features_path = Path(__file__).parent / "features"
  
      if not features_path.exists():
          logger.warning(f"Features directory not found: {features_path}")
          return
  
      # Discover all feature modules
      feature_count = 0
      for _, feature_name, is_pkg in pkgutil.iter_modules([str(features_path)]):
          if not is_pkg:
              continue  # Skip non-package modules
  
          try:
              # Import the tool module from the feature
              tool_module_name = f"{features_package}.{feature_name}.tool"
              tool_module = importlib.import_module(tool_module_name)
  
              # Check if the module has a register_tool function
              if hasattr(tool_module, "register_tool"):
                  # Register the tool, passing the bible service
                  tool_module.register_tool(mcp, self.bible_service)
                  feature_count += 1
                  logger.info(f"✓ Registered tools from feature: {feature_name}")
              else:
                  logger.warning(f"Feature '{feature_name}' has no register_tool() function")
          except ModuleNotFoundError:
              # Feature doesn't have a tool.py, skip it
              logger.debug(f"Feature '{feature_name}' has no tool.py, skipping")
          except Exception as e:
              logger.error(f"Error registering tools from feature '{feature_name}': {e}")
      logger.info(f"Registered MCP tools from {feature_count} features")