What is an MCP greeting card integration?
An MCP greeting card integration connects a greeting card service to an AI agent through the Model Context Protocol (MCP) — the open standard for agent-to-tool communication — so the agent can create, schedule, and manage personalized digital greeting cards as native tool calls.
Instead of an agent fumbling through raw API documentation, an MCP server exposes its capabilities in a structured, discoverable way. The agent sees what tools exist, reasons about when to use them, and invokes them autonomously.
Greetu’s MCP server gives agents exactly that: six tools covering the full card lifecycle — create, schedule, list, read replies, read reactions, and reply. One endpoint, one API key, and any MCP-compatible agent can send a real, AI-written greeting card as a step inside a larger workflow.
- Endpoint:
POST https://greetu.io/api/mcp(JSON-RPC 2.0) - Auth:
X-API-Key: grtu_... - Clients: Claude Desktop, Cursor, VS Code, ChatGPT, Gemini, or any MCP client
- Full docs & key signup: https://greetu.io/mcp
Why agents need a greeting card tool
Here’s the gap in almost every AI agent setup today: agents can already send email, update a CRM, and trigger payments. Those are all transactional. None of them are relational.
A thank-you email from a bot is spam. A thank-you card from a bot is a moment.
The occasions where this matters map directly onto what agents are already doing:
- A sales agent closes a deal in the CRM → sends a congratulations card to the champion while the win is fresh
- A customer success agent detects a renewal or milestone → sends a recognition card, not another templated email
- A personal assistant agent learns a birthday is coming → schedules a card to unlock on the date, automatically
- An HR agent processes a work anniversary → the employee hears about it on the actual day, not whenever someone remembered
The agent already has the context that makes a card personal — the relationship, the history, the occasion. The MCP server is the plug that connects it to the delivery.
Why legacy greeting card platforms can’t do this
Search any established greeting card service for “MCP,” “agent tool,” or “Model Context Protocol” — you won’t find it. These platforms were built around a human workflow: browse templates, edit layouts, type a message, hit send. Their entire data model assumes a person making choices at every step.
Exposing that to an agent would mean wrapping a brittle web UI in browser automation — slow, fragile, and incapable of reasoning. An agent-native card tool needs to work differently:
- Structured inputs. Recipient, occasion, and context in — finished card out. The agent supplies meaning; the service supplies design and craft.
- Deterministic behavior. One tool call produces one card, every time.
- Composable. The tool slots into workflows alongside the agent’s other tools.
- Bidirectional. The agent doesn’t just send — it reads replies and reactions, so a card becomes a conversation, not a broadcast.
Greetu is built on an API where card design and message writing are generated programmatically and delivered digitally and instantly. The MCP layer sits natively on top of that — not bolted on.
The Greetu MCP tools
Six tools, returned by
tools/list:Table
| Tool | Cost | What it does |
|---|---|---|
greetu.create_card | 5 cr | Create a card with an AI-generated or custom message |
greetu.schedule_card | 5 cr | Create a card that unlocks automatically at a future time |
greetu.list_cards | 1 cr | List recently created cards |
greetu.get_replies | 1 cr | Fetch text replies left on a card |
greetu.get_reactions | 1 cr | Fetch emoji reactions left on a card |
greetu.reply_to_card | 3 cr | Send a reply message to a card |
The
create_card schema shows how deliberately agent-friendly the design is — only two required fields:JSON
{
"type": "object",
"properties": {
"recipient_name": { "type": "string", "description": "Name of the person receiving the card" },
"sender_name": { "type": "string", "description": "Your name (optional)" },
"occasion": { "type": "string", "description": "birthday, anniversary, mothers_day, etc." },
"theme": { "type": "string", "description": "Visual theme (optional)" },
"message": { "type": "string", "description": "Custom message (omit if use_ai_message=true)" },
"use_ai_message": { "type": "boolean", "description": "Let AI generate the message" },
"locked_until": { "type": ["string", "null"], "description": "ISO date to lock the card until" },
"voice_message": { "type": ["string", "null"], "description": "Base64 audio (optional)" }
},
"required": ["recipient_name", "occasion"]
}That
voice_message field deserves a second look: an agent can attach a recorded voice message to a card as base64 audio. Text agents can’t fake that warmth — this tool can.Setup: calling the endpoint directly
Greetu’s MCP server is a remote HTTP endpoint, so there’s nothing to install. A raw JSON-RPC call looks like this:
bash
curl -X POST https://greetu.io/api/mcp \
-H "Content-Type: application/json" \
-H "X-API-Key: grtu_xxxxxxxx" \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "greetu.create_card",
"arguments": {
"recipient_name": "Mom",
"occasion": "mothers_day",
"use_ai_message": true
}
}
}'Or in Python:
Python
import requests
API_KEY = "grtu_xxxxxxxx"
URL = "https://greetu.io/api/mcp"
def mcp_call(method, params=None):
r = requests.post(URL, headers={
"Content-Type": "application/json",
"X-API-Key": API_KEY,
}, json={
"jsonrpc": "2.0",
"id": 1,
"method": method,
"params": params or {},
})
return r.json()
print(mcp_call("tools/list"))
result = mcp_call("tools/call", {
"name": "greetu.create_card",
"arguments": {
"recipient_name": "Sarah",
"occasion": "birthday",
"use_ai_message": True,
}
})
print(result)Setup: connecting your agent client
Claude Desktop — save to
~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):JSON
{
"mcpServers": {
"greetu": {
"url": "https://greetu.io/api/mcp",
"headers": {
"X-API-Key": "grtu_xxxxxxxx"
}
}
}
}Cursor — save to
~/.cursor/mcp.json:JSON
{
"mcpServers": {
"greetu": {
"type": "http",
"url": "https://greetu.io/api/mcp",
"headers": {
"X-API-Key": "grtu_xxxxxxxx"
}
}
}
}VS Code — save to
.vscode/mcp.json in your workspace:JSON
{
"servers": {
"greetu": {
"type": "http",
"url": "https://greetu.io/api/mcp",
"headers": {
"X-API-Key": "grtu_xxxxxxxx"
}
}
}
}What an agent workflow looks like in practice
User: “It’s Marcus’s 5-year anniversary with us on Friday — make sure he’s recognized.”Agent: callsgreetu.schedule_cardwith recipient name, occasion, and Friday’s dateGreetu: creates the card; AI writes the message; the card unlocks automatically Friday morningFriday: Marcus opens the card, reacts with 🎉Agent (if asked): callsgreetu.get_reactionsand reports back — “Delivered and loved.”
The schedule tool plus the Time Capsule-style locking means an agent can handle the entire “remember the date” problem, not just the sending. And the read-back tools mean a card sent by an agent can still become a two-way conversation.
Frequently asked questions
What is an MCP greeting card integration? It’s a connection, via the Model Context Protocol, between an AI agent and a greeting card service. The agent gains tools to create, schedule, list, and manage personalized digital greeting cards natonomously — for birthdays, anniversaries, thank-yous, and milestones — without leaving its workflow.
Does Greetu have an MCP server? Yes. It’s a remote HTTP MCP server at
https://greetu.io/api/mcp, authenticated with an X-API-Key header. Full documentation, schemas, and key signup are at https://greetu.io/mcp.Which AI agents work with the Greetu MCP server? Any MCP-compatible client — Claude Desktop, Cursor, VS Code, ChatGPT, Gemini, and others.
What tools does the Greetu MCP server expose? Six:
create_card and schedule_card (5 credits each), reply_to_card (3 credits), and list_cards, get_replies, and get_reactions (1 credit each). Card creation supports AI-written messages, custom messages, themes, scheduled unlocking, and voice messages.Do I need to write code to use it? No. The setup is declarative — paste the server config into your MCP client with your API key, and the agent discovers the tools. Direct JSON-RPC calls from code also work for custom integrations.
Can an agent send a card with a voice message? Yes. The
create_card and schedule_card tools accept a base64-encoded audio file via the voice_message field, which plays directly on the recipient’s card page.What happens after a card is sent? Can the agent follow up? Yes. Agents can poll
get_replies and get_reactions to see how recipients responded, and use reply_to_card to continue the conversation — a card sent by an agent can become a two-way interaction.