Give your AI agent real tools.
YourMCP is a Model Context Protocol server you can ship today. One service registry, exposed identically over CLI, MCP, and HTTP, so any agent that speaks MCP can call it.
Triage my inbox and draft replies.
I triaged your inbox. Here's the curated view.
Triage my inbox and draft replies.
Here's your inbox, triaged by priority.
Triage my inbox and draft replies.
On it. Running the inbox tool now.
goose · 9:42 AM
Triage my inbox and draft replies.
Triaged your inbox in agent mode:
Ask Copilot
Works with every MCP client
- Claude
- Codex
- Cursor
- ChatGPT
- VS Code
- OpenClaw
- Goose
One tool. Three transports.
Write a service once and call it identically from the CLI, any MCP client, or plain HTTP. Same inputs, same outputs, zero duplicated logic. Pick yours to get set up.
Install the CLI
Clone the template and sync dependencies with uv. The mymcp command is ready to run.
git clone https://github.com/Miyamura80/MCP-Template
cd MCP-Template && make all Add it to your client
The server runs over streamable HTTP, so onboarding is just its URL. Pick your client: one click where deep links are supported, copy-and-paste everywhere else.
https://your-app.up.railway.app/mcp Opens Cursor and adds the server. Not working? Copy the URL above and add it under Settings → MCP.
Opens VS Code and adds the server. Requires the GitHub Copilot / MCP support.
Opens Goose and adds the extension over streamable HTTP.
- 1 Open Claude → Settings → Connectors
- 2 Click “Add custom connector”
- 3 Paste the URL above, then click Add
- 1 Settings → Connectors → Advanced: turn on Developer mode
- 2 Click Create
- 3 Paste the URL above, then click Create
Point at the endpoint
No install required: the HTTP API is live at your deployment URL. Authenticate with a bearer token and call it from anything.
export YOURMCP_URL=https://your-app.up.railway.app
export TOKEN=sk-... # OAuth 2.1 bearer Call a tool
Invoke any service straight from your shell: typed inputs, structured output.
$ mymcp gmail-curate-inbox --limit 3
0.86 Re: Q3 contract redlines [email protected] ✎ draft
0.61 Design review for v2 dashboard [email protected]
0.42 Your invoice is ready [email protected] Call a tool
Your agent discovers the tools automatically and calls them with typed inputs. The same service answers two ways:
The default: a pure service returns its typed output model. FastMCP derives the outputSchema, so the CLI, API, and MCP all behave identically.
// client → server · JSON-RPC over streamable HTTP
{
"method": "tools/call",
"params": {
"name": "gmail_curate_inbox",
"arguments": { "limit": 3 }
}
}
// server → client · structured output
{
"content": [{ "type": "text", "text": "3 threads ranked. Top: Q3 contract redlines" }],
"structuredContent": {
"threads": [
{ "subject": "Re: Q3 contract redlines", "importance_score": 0.86, "has_draft": true },
{ "subject": "Design review for v2 dashboard", "importance_score": 0.61, "has_draft": false }
]
}
} Opt the same tool into an @enhance handler and it can elicit input, attach media, or render an MCP App: a sandboxed iframe dashboard your client embeds inline. MCP-only; the CLI and API stay untouched.
Triage my inbox and draft replies.
Here's your inbox, triaged by priority.
Call a tool
Hit the same service over plain HTTP: identical inputs and outputs as the CLI and MCP.
$ curl -s $YOURMCP_URL/api/v1/services/gmail_curate_inbox \
-H "Authorization: Bearer $TOKEN" \
-H "Content-Type: application/json" \
-d '{ "limit": 3 }'
{ "threads": [
{ "subject": "Re: Q3 contract redlines", "importance_score": 0.86, "has_draft": true },
{ "subject": "Design review for v2 dashboard", "importance_score": 0.61, "has_draft": false }
] } One codebase, every surface
Write a tool once. Ship it to agents, scripts, and services without rewrites.
- 01
Three transports, zero duplication
Every tool is a pure function in a shared registry, exposed identically over CLI, MCP, and HTTP. Behavior never drifts between interfaces.
- 02
Headless or interactive
Return data for autonomous agents, or opt into enhanced tools that elicit input, attach media, and render sandboxed UI dashboards.
Trusted by builders
“We had a production MCP server in front of our agents the same afternoon. The shared registry meant our CLI and API just worked too.”
Placeholder NameStaff Engineer, Placeholder Co.“The typed schemas are the killer feature. Our agent stopped guessing argument shapes overnight.”
Placeholder NameFounder, Placeholder AIAsk AI about this
Have your assistant explain the template, compare it, or walk you through deploying it.
Frequently asked questions
Which MCP clients are supported?
Any client that speaks the Model Context Protocol: Claude Desktop, Claude Code, Cursor, Cline, VS Code, Windsurf, and more. The server exposes a standard tool/resource surface.
stdio or streamable HTTP?
Both. Streamable HTTP is the primary transport (mounted at /mcp alongside the HTTP API in one process), and stdio is available for local/dev use.
How does authentication work?
The MCP mount supports OAuth 2.1 as a resource server, sharing auth and CORS with the HTTP API. You can also run it unauthenticated for local development.
Do I need to install anything to use it?
No. Because the server runs over streamable HTTP, connecting is just pasting its URL into your agent client. No local install, runtime, or download required. (Self-hosting the server is a separate, optional step.)
Does it work on mobile?
Yes, anywhere your agent runs. Since it's a remote HTTP server with nothing to install locally, it works in any agent app that has a mobile app, including the Claude and ChatGPT mobile apps.
Can I self-host?
Yes. The whole thing is open source and ships with a Dockerfile and Railway config. Deploy it anywhere that runs a container.
What about my existing CLI / API?
They share the same service registry. Add a tool once and it's available over CLI, MCP, and HTTP simultaneously, with no duplicated logic.
Ship your MCP server today.
Clone the template, deploy it, and point your agent at the URL.
- Three transports, one codebase
- Headless or interactive tools
- Streamable HTTP, one port
- Open source, self-hostable