Connect Your AI Agent to 200+ Utility Tools over MCP: A Hands-On Guide

LLMs are good at reasoning and bad at arithmetic, byte-exact string handling and anything that touches a real file. The Model Context Protocol (MCP) fixes that by letting an agent call a deterministic tool in the middle of a conversation instead of guessing.

This guide walks through connecting an MCP client to the FreeDailyPro MCP server, checking what it exposes, and running a few real tool calls. Every request and response below was captured from the live server on 31 Oct 2026. Only the API key has been removed.

What you're connecting to

FreeDailyPro runs one API at api.freedailypro.com with two front doors:

• REST, 200+ endpoints (PDF, PowerPoint, media, calculators, text and developer utilities)
• MCP, 200+ tools at https://api.freedailypro.com/mcp, listed in the official MCP Registry as com.freedailypro/tools

Both use the same key and the same pool of calls. According to the developers page, files and text are processed in memory and nothing you send is stored.

Step 1: Get a key

Sign in with Google on the developers page to create an API key. A Trial plan with 20,000 calls a month comes with it (more on limits below). The key goes in an X-API-Key header.

Step 2: Configure your MCP client

The server uses MCP's Streamable HTTP transport, so any client that supports remote servers with custom headers can connect directly. In Cursor, add this to ~/.cursor/mcp.json (or .cursor/mcp.json in a project):

{
  "mcpServers": {
    "freedailypro": {
      "url": "https://api.freedailypro.com/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      }
    }
  }
}

Other MCP clients that support remote HTTP servers with custom headers can use the same URL and X-API-Key header.

Restart the client and the tools should appear in its tool picker.

Step 3: Check the handshake yourself

It's worth seeing the raw protocol once, because it makes debugging much easier later. Here's initialize with plain curl:

curl -s https://api.freedailypro.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "X-API-Key: $FDP_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize",
       "params":{"protocolVersion":"2025-06-18","capabilities":{},
                 "clientInfo":{"name":"devto-demo","version":"1.0"}}}'

The server answers as a server-sent event:

event: message
data: {"result":{"protocolVersion":"2025-06-18","capabilities":{"tools":{"listChanged":true}},"serverInfo":{"name":"freedailypro-utility-tools","version":"0.3.0"}},"jsonrpc":"2.0","id":1}

Next, tools/list (same headers, "method":"tools/list") returns the catalogue. Each tool has a JSON Schema for its input and annotations a client can use when deciding whether to ask for confirmation. Here's one entry:

{
  "name": "generate_slug",
  "description": "Slug generator — SEO-friendly URL slug",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": { "type": "string" },
      "lowercase": { "type": "boolean" },
      "separator": { "type": "string", "maxLength": 3 },
      "maxLength": { "type": "number", "minimum": 0, "maximum": 500 },
      "removeStopWords": { "type": "boolean" }
    },
    "required": ["text"],
    "additionalProperties": false
  },
  "annotations": {
    "title": "Generate Slug",
    "readOnlyHint": true,
    "destructiveHint": false,
    "idempotentHint": true,
    "openWorldHint": false
  }
}

Send one JSON-RPC request per HTTP call. That's the pattern the current MCP spec expects, and it's what every mainstream client does anyway.

Step 4: Real tool calls

Here are three calls I'd actually want an agent to hand off rather than work out in its head.

Use case 1: Loan math the model can't get wrong

Ask an agent "What's the monthly payment on a $25,000 loan at 6.5% over 5 years, starting December 1?" and the model is likely to round somewhere along the way. With the tool connected, it calls calculate_loan instead:

{"jsonrpc":"2.0","id":5,"method":"tools/call",
 "params":{"name":"calculate_loan",
   "arguments":{"principal":25000,"annualRatePercent":6.5,"years":5,
                "previewMonths":2,"firstPaymentDate":"2026-12-01"}}}

Response (the tool's content[0].text):

{
  "monthlyPayment": 489.15,
  "totalPayment": 29349.22,
  "totalInterest": 4349.22,
  "schedulePreview": [
    { "month": 1, "principal": 353.74, "interest": 135.42, "balance": 24646.26, "date": "2026-12-01" },
    { "month": 2, "principal": 355.65, "interest": 133.5,  "balance": 24290.61, "date": "2027-01-01" }
  ],
  "firstPaymentDate": "2026-12-01",
  "lastPaymentDate": "2031-11-01",
  "payoffDate": "2031-11"
}

The schema also does useful work. My first attempt used annualRate, and the server rejected it with a clear validation error naming the right field (Required at annualRatePercent) rather than guessing. Agents recover from errors like that well.

Use case 2: Inspecting a JWT while debugging auth

When you're debugging an auth flow with an agent, decode_jwt gives it structured claims plus a few sanity checks. Using the well-known sample token from jwt.io:

{"jsonrpc":"2.0","id":6,"method":"tools/call",
 "params":{"name":"decode_jwt","arguments":{"token":"eyJhbGciOiJIUzI1NiIs..."}}}

{
  "valid": true,
  "wellFormed": true,
  "status": "ok",
  "signatureVerified": false,
  "issues": [
    "There is no 'exp' claim, so the token never expires by its own claims."
  ],
  "header": { "alg": "HS256", "typ": "JWT" },
  "payload": { "sub": "1234567890", "name": "John Doe", "iat": 1516239022 },
  "algorithm": "HS256",
  "issuedAt": "2018-01-18T01:30:22.000Z"
}

Note signatureVerified: false. The tool decodes the header and payload only and doesn't claim to verify signatures. The issues array flagging the missing exp claim is a good prompt for the agent to raise with you. As with any third-party service, don't paste production tokens you wouldn't share.

Use case 3: Small content-pipeline chores

For agents that draft posts, docs or changelogs, deterministic helpers like generate_slug save a round of back-and-forth:

{"jsonrpc":"2.0","id":3,"method":"tools/call",
 "params":{"name":"generate_slug",
   "arguments":{"text":"Connect Your AI Agent to 200+ Tools with MCP!"}}}

{"result":{"content":[{"type":"text","text":"connect-your-ai-agent-to-200-tools-with-mcp"}]},"jsonrpc":"2.0","id":3}

The same catalogue includes PDF tools (merge, split, compress, redact, form fill), PowerPoint tools (build a deck from Markdown, JSON or CSV, extract notes, merge), ffmpeg-backed audio and video operations, and a long list of finance and planning calculators. File tools are the obvious next step once you're comfortable with the text-in, JSON-out ones.

Limits and pricing

Every response carries rate-limit headers, so your code (or agent) can see where it stands:

x-ratelimit-limit: 20000
x-ratelimit-remaining: 15221

As listed on the developers page, calls come from one shared monthly pool across every REST endpoint and MCP tool:

Plan	Price	Calls per month
Trial	$0	20,000
Premium	$24 / month	200,000
Ultra	$69 / month	750,000
Mega	$129 / month	2,000,000, plus priority support

Full details are on the pricing page.

The developers page also lists what isn't covered: OCR, Word and Excel conversion, and anything that needs live camera, screen or microphone access. If your workflow depends on those, plan around them for now.

Wrapping up

The setup comes down to one URL and one header, and the payoff is an agent that hands exact work to tools that return the same answer every time. If you want to explore before wiring up a client, the Postman collection and OpenAPI file linked from the developers page document every endpoint with example requests.

Which tools would you want your agent to have that aren't in the list yet? And if you hit a rough edge connecting a particular MCP client, tell me in the comments. That feedback goes straight into what gets built next.