I build MCP servers that make internal systems safely agent-callable.

Specialized Model Context Protocol (MCP) servers for the Claude API. Secure authentication, context routing, and intelligent failover so agents can reach your internal systems—without exposing them.

See the work →

What I build

MCP servers

Custom tools with real input schemas, so Claude and other agents can call your systems directly instead of guessing at them.

Auth & scoped access Context routing Policy enforcement

LLM integration

Claude API work with the parts people skip: provider failover, spend caps, prompt-injection-resistant input handling.

Claude API first Tool calling Failover & resilience

API hardening

Rate limiting, origin enforcement, webhook signature verification, and kill switches for endpoints that burn money when abused.

Input validation Rate limits & quotas Logs & observability

What is broken?

Selected work

Proof, not a pitch deck.

Production MCP server — 42 tools

2,269 LOC42 tools21 general-purpose

A single well-scoped MCP server rather than a scatter of thin ones. Of 42 registered tools, 21 are general-purpose utilities an agent would reach for against any codebase — diff_text, cron_explain, json_to_ts, jwt_decode, hash_text. The rest are host and catalog operations specific to the system it serves.

The design principle was that every tool had to be one an agent would reach for unprompted. Earlier stub-only servers were cut.

{
  "name": "cron_explain",
  "description": "Explain a cron expression in plain English",
  "inputSchema": {
    "type": "object",
    "properties": { "expression": { "type": "string" } },
    "required": ["expression"]
  }
}

Node.js · MCP SDK · Vercel serverless

Try the live server →

Public AI endpoint hardening

326 LOCguard layer6 controls

A public button that calls a paid LLM API is an open invitation to burn someone else's API budget. This layer exists to make that expensive and boring for an attacker.

Serverless rate limits are best-effort and are not a global wallet, so provider-side hard spend caps back all of it.

Control	Behavior
Kill switch	Single env var returns 503 globally; free features keep working
Origin required	No first-party Origin → 403 — no bare curl
CORS allowlist	Explicit host list, never wildcard
Secret rejection	Input matching `sk-`, `ghp_`, private keys refused
Tiered limits	Per-IP sliding windows: minute / hour / day
Body caps	Hard payload ceiling

Node.js · Vercel · sliding-window rate limiting

Multi-provider LLM failover

5 providersCost-ordered

A generation endpoint that degrades instead of failing. Providers are tried in cost order — smallest capable model first — across Moonshot, NVIDIA, xAI, OpenAI, and Groq, with per-task routing so cheap tasks never touch expensive models.

Most of the engineering is in the unhappy paths: distinguishing a rate-limit from an outage from a malformed response.

Node.js · Moonshot/Kimi · NVIDIA NIM · xAI · OpenAI · Groq

Stripe checkout & entitlement system

Webhook fulfillmentDurable ledger

End-to-end purchase flow: dynamic per-product Checkout Sessions, signature-verified webhooks, and entitlement verification that treats Stripe as source of truth rather than trusting the client.

A missed webhook degrades into a delay rather than a customer who paid and got nothing.

Stripe API · webhooks · SQLite · HMAC sessions

See unlocks on Forge →

JSON → TypeScript interface generator

Client-sideNever leaves the page

Paste JSON, get typed interfaces. Nested objects, mixed arrays, optional-field inference. The payload never leaves the browser — which matters when what someone is pasting is a production API response.

TypeScript · client-side only

Open the live tool →

Home Assistant LLM automation

107KB generatorLive deployment

A generated multi-panel dashboard for a live Home Assistant install, plus a conversational layer that routes natural-language household queries to an LLM with fallback when providers are unreachable.

Entity-state reconciliation, template sensor generation, and a probe harness for fallback without waiting for a real outage.

Python · Home Assistant API · Jinja2 templates

How I work

Small enough to judge. Written enough to survive.

I scope a first milestone small enough that you can judge the work before committing to the rest. For MCP projects that usually means two or three working tools against your actual data, deployed where you can call them — not a document describing what I would build.

I write things down. You get the schema decisions and the failure modes in writing, because the part that bites later is always the unhappy path nobody specified.

How engagements usually start: a first milestone at $500–800 — two or three working tools against your real data, deployed where you can call them. If that milestone doesn't convince you, you have spent the price of an afternoon rather than the price of a project.

Referrals

If you know someone who needs an MCP server built or an LLM integration that holds up in production, send them my way. I pay $250 on any contract that clears $2,500 — paid once the client has paid me.

Your name — I'll build you a link

Share that link. When someone arrives through it and gets in touch, your name is already on the enquiry.

Start a conversation

What is broken?

Or email directly — justin@justindkamen.com (open in mail client)