Schema Laravel Package

Product Decisions This Supports

• Feature viability: "expose our Laravel app to AI clients." This package is the typed contract layer for the Model Context Protocol — DTOs for Tool, Resource, Prompt, content blocks (text/image/embedded resource), JSON-RPC request/response envelopes, and enums for roles, protocol versions, and client/server capabilities. It lets you scope an MCP feature by answering "what do we advertise, and in what shape?" before committing to transport, auth, or hosting work.
• Build vs. buy on the type layer. The alternative is hand-writing and maintaining PHP classes that mirror a spec that is still moving. Adopting this package converts an ongoing spec-tracking chore into a version bump — a clear buy signal if the package keeps pace.
• Roadmap sequencing and cost of a spike. Because this is types-only (no server, no routing, no transport), it is the cheapest possible first increment: an engineer can produce a spec-shaped payload in hours. That makes "should we support MCP at all?" a one-sprint experiment rather than a quarterly bet.
• Protocol standardization: MCP vs. OpenAPI/function-calling. Typed MCP messages let you compare an MCP tool surface against your existing REST/OpenAPI surface on equal footing — same inputs, same serialization concerns — before picking a direction.
• Integration use cases this unlocks for evaluation: internal developer tooling (Claude Desktop, Cursor, IDE agents hitting your app), customer-facing agent integrations, and exposing read-only domain resources (catalog, docs, tickets) as MCP resources rather than bespoke endpoints.
• Contract-stability decisions. The enums and DTOs force explicit decisions on protocol version pinning and on how much of the spec you claim to support — useful inputs for a public API/SDK commitment and for deprecation policy.
• Interoperability positioning. If you ship MCP-shaped output, the same payload works across multiple AI clients. That's a distribution argument, not just an engineering one.

When to Consider This Package

Consider it when:

• You are building an MCP server or client in PHP/Laravel and want the message layer typed instead of passing associative arrays around.
• You want MCP types isolated from your domain models — DTOs give you a clean serialization boundary and testable fixtures.
• You are running a time-boxed spike to prove an MCP endpoint; the cost of adoption is one Composer entry.
• You plan to pair it with a transport/server package in the same family, so the schema version and the transport version move together.
• You value MIT licensing and zero runtime footprint over vendor backing.

Look elsewhere when:

• A first-party Laravel MCP package now covers this. Verify before adopting — an official package would make this redundant and better supported.
• You need transport, HTTP routing, auth/OAuth, or session handling — this package does none of that. Buying it expecting a framework is the most likely disappointment.
• You only need to call one tool from one client: raw arrays and an HTTP client are cheaper than a dependency.
• You require vendor support, an SLA, or a security review trail. At ~19 stars with an unattributed repository, treat maintenance as unproven.
• The package's protocol version lags current spec revisions, or release cadence is unclear. MCP is churning; stale types are worse than no types.
• Your stack isn't PHP, or you need the schema at a boundary where a language-neutral IDL (OpenAPI/JSON Schema) already exists.

Adoption guardrails: pin an exact version, wrap the DTOs behind your own adapter/factory layer so a swap is a one-file change, and record the supported protocol version in your docs. Do repository due diligence — maintainer identity, release history, issue responsiveness — before it becomes load-bearing.

How to Pitch It (Stakeholders)

For executives: This is a small MIT-licensed PHP package that gives us ready-made, typed definitions for the Model Context Protocol — the emerging standard for letting AI assistants call into applications. It is not a product; it is the vocabulary layer. For roughly a day of engineering, it lets us prototype "expose our app to Claude, Cursor, and similar clients" without hand-maintaining a moving specification. Cost is near zero, lock-in is near zero, and the strategic value is optionality: it tells us quickly whether MCP is worth a roadmap line before we spend a quarter finding out.

For engineering: This is DTOs and enums only — no server, no routing, no transport. It buys you spec-shaped payloads, serialization, and type safety, and it keeps protocol churn out of your domain code. Two caveats: the project is early (low star count, unattributed repo), so pin the version and hide it behind our own adapter; and confirm no first-party Laravel MCP package already supersedes it. If either caveat bites, the fallback — our own thin type layer — is a few days of work, which is exactly why this is a low-risk bet rather than an architecture decision.