You are tasked to build a comprehensive MCP server.

<purpose>
Fetch the appropriate actions you have access to, and determine the best path for producing the outcome from your user's chat inputs.
</purpose>

<tech-stack>
- Node.js
- Axios (Web requests)
- Cheerio (DOM scraping)
- zod (for validation)
- @modelcontextprotocol/sdk (^1.10.2)
</tech-stack>

<todo>
0. Research and create API documentation for this build from @<https://developer.getjobber.com/docs>  and @<https://developer.getjobber.com/docs/using_jobbers_api/api_queries_and_mutations/> and @<https://developer.getjobber.com/docs/using_jobbers_api/custom_fields/> and @<https://developer.getjobber.com/docs/using_jobbers_api/handling_api_errors/> and @<https://developer.getjobber.com/docs/using_jobbers_api/setting_up_webhooks/> 
1. Set install the dependencies in the current directory.
2. Create comprehensive functions with testing from your resource documents
3. Build a chat interface that will interface with the MCP server and facilitate these functions using the anthropic key in the .env file
4. Leveraging anthropic, you'll need need to field and respond to user inputs to faciliate the functions relevant to their commands
5. Return the confirmation of what you've done to the user after successful command completions
</todo>

Use the latest, accurate documention and examples below.

<documentation>
```javascript
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { z } from 'zod'

// Create an MCP server
const server = new McpServer({
  name: 'my-mcp-server',
  version: '0.1.0',
});

/**
 * Perform a hello
 */
async function performHello(query: string) {
  return `Hello {$query}. This is a response from the MCP server!`;
}

// Add a tool
server.tool(
  'hello',
  {
    query: z.string().describe('The query'),
  },
  async ({ query }) => {
    try {
      const result = await performHello(query);
      return {
        content: [
          {
            type: 'text',
            text: result,
          },
        ],
      };
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      return {
        content: [
          {
            type: 'text',
            text: `Error: ${errorMessage}`,
          },
        ],
        isError: true,
      };
    }
  }
);

// Start the server
const transport = new StdioServerTransport();
server.connect(transport).catch((error) => {
  console.error('[MCP Error]', error);
  process.exit(1);
});

console.error('MCP server running on stdio');

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const client = new Client({name: "client-name", version: "0.1.0"});
await client.connect(new StdioClientTransport({
  command: "node", args: ["server-file.js"]
}));

const result = await client.callTool({
  name: "toolName", arguments: { paramName: "value" }
});

CoinGecko LD+JSON example:

    <script type="application/ld+json">
    {
      "@context": "<https://schema.org>",
      "@type": "ExchangeRateSpecification",
      "url": "<https://www.coingecko.com/en/coins/bitcoin>",
      "name": "Bitcoin",
      "currency": "BTC",
      "currentExchangeRate": {
        "@type":"UnitPriceSpecification",
        "price": 86031.69227069775,
        "priceCurrency": "USD"
      }
    }
    </script>

Return the result or error in a simplified JSON format like:

{
  "status": "success",
  "data": {
    "asset": "Bitcoin",
    "price": 86031.69227069775,
    "currency": "USD"
  }
}

{
  "status": "error",
  "message": "The price was not found on the website.",
}

</documentation>

Do not write documentation, no readme, no usage or anything at all other than mandatory code.

Implement web scraping logic and error handling.

Document the file well so beginner coders can make sense of your code and learn from it.

Make sure to follow the steps outlined above and return the results in the specified JSON formats.

Keep the implementation minimal and focused on the required functionality.