{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"awesome-php-mcp-sdk","slug":"php-mcp-sdk","name":"PHP MCP SDK","type":"mcp","url":"https://github.com/modelcontextprotocol/php-sdk","page_url":"https://unfragile.ai/php-mcp-sdk","categories":["mcp-servers"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"awesome-php-mcp-sdk__cap_0","uri":"capability://tool.use.integration.attribute.based.capability.declaration.with.schema.auto.generation","name":"attribute-based capability declaration with schema auto-generation","description":"Developers declare MCP capabilities (tools, resources, prompts) using PHP attributes (#[McpTool], #[McpResource], #[McpPrompt]) on class methods. The SDK's Discoverer and SchemaGenerator components automatically parse DocBlocks and method signatures using phpdocumentor/reflection-docblock to generate JSON Schema definitions for each capability, eliminating manual schema maintenance. This approach integrates with the Builder pattern to accumulate and register capabilities during server initialization.","intents":["I want to expose a PHP function as an MCP tool without writing JSON schemas manually","I need to generate OpenAPI/JSON Schema documentation from my existing PHP code","I want to ensure my tool definitions stay in sync with actual method signatures"],"best_for":["PHP developers building MCP servers who want rapid capability exposure","teams migrating existing PHP codebases to MCP without schema rewriting","developers using IDE autocompletion and type hints as documentation"],"limitations":["DocBlock parsing is limited to PHPDoc format — non-standard documentation won't be captured","Complex nested types in method signatures may require manual schema refinement","Attribute discovery requires explicit class scanning — no automatic file globbing without Symfony Finder integration"],"requires":["PHP 8.1+ (attributes introduced in PHP 8.0)","phpdocumentor/reflection-docblock dependency","PSR-4 autoloading for class discovery"],"input_types":["PHP class methods with attributes","PHPDoc comments","Type hints (scalar, class, union types)"],"output_types":["JSON Schema objects","MCP capability definitions (tools, resources, prompts)","OpenAPI-compatible schemas"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_1","uri":"capability://automation.workflow.builder.pattern.server.assembly.with.fluent.configuration","name":"builder-pattern server assembly with fluent configuration","description":"The Server\\Builder class (src/Server/Builder.php) implements a fluent builder pattern that accumulates MCP server configuration through method chaining. Developers call methods like ->addTool(), ->addResource(), ->addPrompt() to register capabilities, then ->build() constructs the complete Server instance with all dependencies wired. The builder manages capability loaders (ArrayLoader, Discoverer), transport configuration, session stores, and request handlers, providing a single assembly point that enforces initialization order and dependency injection.","intents":["I want to configure an MCP server with tools, resources, and prompts in a readable, chainable way","I need to swap transport layers (STDIO vs HTTP) without rewriting server logic","I want to inject custom session stores or request handlers into the server"],"best_for":["PHP developers building MCP servers who prefer fluent APIs over configuration files","teams needing flexible server assembly for multiple deployment contexts (CLI, HTTP, containerized)","developers integrating MCP servers into existing PHP frameworks (Laravel, Symfony)"],"limitations":["Builder state is mutable — no immutability guarantees if builder is reused after build()","Complex capability registration logic must be expressed through method chaining, which can become verbose for 50+ capabilities","No built-in validation of capability conflicts or duplicate registrations until build() is called"],"requires":["PHP 8.1+","psr/container implementation for dependency injection","symfony/uid for session ID generation"],"input_types":["capability objects (Tool, Resource, Prompt instances)","transport configuration (STDIO, HTTP)","session store implementations (PSR-16 compatible)"],"output_types":["fully constructed Server instance","wired request handlers and capability registry"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_10","uri":"capability://safety.moderation.error.handling.with.mcp.compliant.error.responses","name":"error handling with mcp-compliant error responses","description":"The SDK implements comprehensive error handling that catches exceptions during capability execution and converts them to MCP-compliant error responses with proper error codes and messages. The error handling pipeline includes validation errors (argument schema mismatches), execution errors (capability handler exceptions), and protocol errors (malformed requests). Each error type is mapped to an appropriate MCP error code (e.g., -32600 for invalid request, -32603 for internal error), with detailed error messages for debugging.","intents":["I want tool execution errors to be returned as proper MCP error responses","I need to distinguish between validation errors and execution errors","I want detailed error messages for debugging without exposing internal details to clients"],"best_for":["developers building robust MCP servers with proper error handling","teams needing clear error messages for debugging","applications requiring MCP-compliant error responses"],"limitations":["Error messages may expose internal details if not carefully filtered","Custom exception types must be explicitly mapped to MCP error codes","No built-in error logging — must be implemented separately"],"requires":["PHP 8.1+","exception handling in capability handlers","error code mapping configuration"],"input_types":["exceptions from capability execution","validation errors from schema validation"],"output_types":["MCP error responses with error codes and messages","error details for logging"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_11","uri":"capability://automation.workflow.protocol.message.routing.and.json.rpc.2.0.serialization","name":"protocol message routing and json-rpc 2.0 serialization","description":"The Server class implements the core MCP protocol message routing logic, handling JSON-RPC 2.0 serialization and deserialization of all MCP requests and responses. The protocol layer routes incoming requests (tools/call, resources/read, prompts/get, etc.) to appropriate request handlers, manages request/response correlation via JSON-RPC IDs, and handles notifications (one-way messages without response). The transport layer abstracts the underlying communication mechanism (STDIO, HTTP), while the protocol layer remains transport-agnostic.","intents":["I want the server to properly route MCP requests to the right handlers","I need JSON-RPC 2.0 serialization and deserialization to work correctly","I want to handle both request/response and notification patterns"],"best_for":["developers building MCP servers that need proper protocol compliance","teams requiring correct JSON-RPC 2.0 message handling","applications needing both request/response and notification patterns"],"limitations":["Protocol routing is synchronous — no built-in async request handling","JSON-RPC 2.0 batch requests are not supported","No built-in request deduplication or idempotency"],"requires":["PHP 8.1+","JSON-RPC 2.0 compliant client","request handlers for each MCP method"],"input_types":["JSON-RPC 2.0 requests (with method, params, id)","MCP protocol requests (tools/call, resources/read, etc.)"],"output_types":["JSON-RPC 2.0 responses (with result/error, id)","MCP protocol responses","notifications (no id)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_12","uri":"capability://text.generation.language.completion.provider.integration.for.llm.context.enhancement","name":"completion provider integration for llm context enhancement","description":"The SDK includes a CompletionProvider capability that allows MCP servers to provide completion suggestions to AI clients, enhancing LLM context with dynamic suggestions based on partial input. Completion providers receive partial text and return a list of completion options with descriptions. This capability is useful for exposing autocomplete functionality, command suggestions, or context-aware recommendations to AI clients. Completion providers are defined similarly to tools and resources, with a handler that generates completions based on input.","intents":["I want to provide autocomplete suggestions to AI clients based on partial input","I need to expose command suggestions or context-aware recommendations","I want to enhance LLM context with dynamic completion options"],"best_for":["developers building AI agents that need autocomplete functionality","teams providing command-line or query interfaces as MCP services","applications requiring context-aware suggestion generation"],"limitations":["Completion providers are text-based — no structured completion formats","No built-in ranking or filtering of completions","Completion generation must be fast to avoid blocking client interactions"],"requires":["PHP 8.1+","completion handler (callable that returns completion options)","partial input text"],"input_types":["partial text (string)","context information (optional)"],"output_types":["completion options (array of strings with descriptions)","error response if generation fails"],"categories":["text-generation-language","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_13","uri":"capability://automation.workflow.conformance.testing.and.inspector.based.validation","name":"conformance testing and inspector-based validation","description":"The SDK includes built-in testing infrastructure with conformance tests that validate MCP protocol compliance and inspector-based testing that captures and validates server behavior. The Inspector component intercepts all MCP messages (requests, responses, notifications) and records them for analysis. Conformance tests verify that the server correctly implements MCP specification requirements (e.g., proper error codes, valid response formats). This enables developers to validate their MCP servers against the specification without manual testing.","intents":["I want to verify my MCP server complies with the MCP specification","I need to test server behavior by capturing and analyzing MCP messages","I want to ensure error responses have correct error codes and formats"],"best_for":["developers building MCP servers who want specification compliance","teams needing automated testing of MCP protocol behavior","organizations requiring validation before production deployment"],"limitations":["Conformance tests are limited to protocol-level validation — no business logic testing","Inspector captures all messages in memory — may consume significant memory for long-running tests","Tests must be run in a test environment — not suitable for production monitoring"],"requires":["PHP 8.1+","PHPUnit or compatible test framework","test fixtures and conformance test suite"],"input_types":["MCP requests and responses","server behavior snapshots"],"output_types":["conformance test results (pass/fail)","captured message logs","validation errors"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_2","uri":"capability://automation.workflow.multi.transport.protocol.abstraction.with.stdio.and.http.support","name":"multi-transport protocol abstraction with stdio and http support","description":"The SDK abstracts communication transport through a Transport interface with concrete implementations for STDIO (StdioTransport) and HTTP (StreamableHttpTransport). The Server class routes all MCP protocol messages through the selected transport, handling JSON-RPC 2.0 serialization, message framing, and bidirectional communication. This abstraction allows the same server logic to run in CLI environments (STDIO) or as HTTP endpoints without code changes, with the transport layer managing session lifecycle and connection state.","intents":["I want to run the same MCP server logic in both CLI (Claude Desktop) and HTTP (web service) contexts","I need to handle long-lived STDIO connections with proper session management","I want to expose MCP capabilities via HTTP endpoints for cloud deployment"],"best_for":["developers deploying MCP servers across multiple environments (local CLI, cloud HTTP, containerized)","teams building AI integrations that need both desktop (Claude Desktop) and server-side access","organizations requiring HTTP-based MCP for firewall/proxy compatibility"],"limitations":["STDIO transport is blocking — no concurrent request handling within a single process","HTTP transport requires external web server (PHP-FPM, Apache) — no built-in HTTP server","Session state is not automatically persisted across HTTP requests — requires external PSR-16 store (Redis, Memcached)"],"requires":["PHP 8.1+","symfony/uid for session ID generation","PSR-16 compatible session store for HTTP deployments (optional for STDIO)"],"input_types":["JSON-RPC 2.0 messages over STDIO or HTTP","MCP protocol requests (tools/call, resources/read, prompts/get)"],"output_types":["JSON-RPC 2.0 responses","MCP protocol responses with results or errors"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_3","uri":"capability://tool.use.integration.capability.registry.with.pluggable.loaders.and.discovery","name":"capability registry with pluggable loaders and discovery","description":"The Capability\\Registry stores all registered tools, resources, and prompts, populated by pluggable loaders (ArrayLoader for manual registration, Discoverer for attribute-based auto-discovery). The registry implements a lookup interface that the Server uses to resolve capability requests by name. Loaders can be chained or composed, allowing hybrid approaches where some capabilities are manually defined and others are auto-discovered from class attributes, with the registry merging results into a unified capability namespace.","intents":["I want to register tools and resources from multiple sources (attributes, arrays, external configs) into a single registry","I need to look up capabilities by name at runtime to execute them","I want to list all available capabilities for MCP discovery responses"],"best_for":["developers building MCP servers with mixed capability sources (some auto-discovered, some manual)","teams needing dynamic capability registration or hot-reloading","frameworks integrating MCP as a plugin system"],"limitations":["Registry is populated at build time — no runtime capability addition without rebuilding the Server","No built-in conflict resolution for duplicate capability names — last registered wins","Loader composition is manual — no automatic loader discovery or ordering"],"requires":["PHP 8.1+","Capability objects (Tool, Resource, Prompt instances)","Loader implementations (ArrayLoader, Discoverer, or custom)"],"input_types":["Capability objects","class names with attributes","array definitions"],"output_types":["capability lookup results","capability lists for discovery","capability metadata (name, description, schema)"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_4","uri":"capability://tool.use.integration.request.handler.execution.with.reference.resolution.and.result.formatting","name":"request handler execution with reference resolution and result formatting","description":"The SDK's request processing pipeline routes incoming MCP requests (tools/call, resources/read, prompts/get) through specialized request handlers that resolve capability references, execute them with validated arguments, and format results. The ReferenceHandler resolves tool/resource/prompt names to actual capability objects, the execution layer invokes the capability with type-coerced arguments, and ResultFormatters convert execution results into MCP-compliant response objects. This pipeline includes error handling that catches exceptions and converts them to MCP error responses with proper error codes.","intents":["I want to execute a tool when an AI client calls it via MCP","I need to validate tool arguments against the schema before execution","I want to handle tool execution errors gracefully and return proper MCP error responses"],"best_for":["developers building MCP servers that execute tools/resources/prompts","teams needing robust error handling and argument validation","applications requiring type coercion between JSON arguments and PHP types"],"limitations":["Argument validation is schema-based — complex custom validation logic must be implemented in the capability handler itself","Type coercion is automatic but limited to scalar types and simple objects — complex nested structures may require manual deserialization","Result formatting assumes capability handlers return simple types — complex result objects must implement __toString() or be manually serialized"],"requires":["PHP 8.1+","opis/json-schema for argument validation","capability objects with executable handlers"],"input_types":["MCP request objects (ToolCallRequest, ResourceReadRequest, PromptGetRequest)","JSON arguments from client","capability references (names)"],"output_types":["MCP response objects (ToolCallResponse, ResourceReadResponse, PromptGetResponse)","error responses with MCP error codes","formatted result content"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_5","uri":"capability://memory.knowledge.session.management.with.psr.16.compatible.stores","name":"session management with psr-16 compatible stores","description":"The SDK implements session management through the Session interface with a PSR-16StoreSession implementation that persists session state to any PSR-16 compatible cache store (Redis, Memcached, file-based). Sessions are identified by UUIDs (via symfony/uid) and store client metadata, request history, and protocol state. The session store is pluggable, allowing developers to use their existing cache infrastructure (Laravel Cache, Symfony Cache) without additional dependencies. Session lifecycle is managed by the Server, with automatic cleanup and timeout handling.","intents":["I want to maintain session state across multiple MCP requests in HTTP deployments","I need to use my existing Redis/Memcached infrastructure for MCP session storage","I want to track client metadata and request history for debugging or auditing"],"best_for":["developers deploying MCP servers in HTTP/stateless environments","teams with existing PSR-16 cache infrastructure (Laravel, Symfony, Drupal)","applications requiring session persistence across server restarts"],"limitations":["Session state is not automatically replicated across multiple server instances — requires distributed cache (Redis, Memcached)","STDIO transport doesn't require session persistence — sessions are ephemeral per connection","No built-in session timeout enforcement — must be implemented in the cache store's TTL"],"requires":["PHP 8.1+","PSR-16 compatible cache implementation (Redis, Memcached, file-based, etc.)","symfony/uid for UUID generation"],"input_types":["session metadata (client info, request history)","protocol state (capabilities, client preferences)"],"output_types":["session objects with stored state","session IDs (UUIDs)"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_6","uri":"capability://tool.use.integration.tool.capability.definition.and.execution.with.argument.validation","name":"tool capability definition and execution with argument validation","description":"Tools are MCP capabilities that represent executable functions exposed to AI clients. The Tool class encapsulates a name, description, JSON Schema for arguments, and an executable handler (callable or class method). When a client calls tools/call, the request handler validates arguments against the schema using opis/json-schema, coerces types to match PHP signatures, invokes the handler, and returns the result. Tools support both synchronous execution and can be defined via attributes (#[McpTool]) with automatic schema generation from method signatures and DocBlocks.","intents":["I want to expose a PHP function as a callable tool to AI clients","I need to validate tool arguments and ensure type safety before execution","I want to document tool parameters and return types in a way that AI clients understand"],"best_for":["developers exposing existing PHP functions as MCP tools","teams building AI agents that need to execute backend operations","applications requiring strict argument validation and type coercion"],"limitations":["Tools are synchronous only — no built-in async/await support","Return types are limited to JSON-serializable values — complex objects must implement custom serialization","Argument validation is schema-based — complex validation logic must be in the handler itself"],"requires":["PHP 8.1+","callable handler (function, method, or closure)","JSON Schema definition for arguments (auto-generated from attributes or manual)"],"input_types":["tool name (string)","arguments (JSON object)","argument schema (JSON Schema)"],"output_types":["tool result (JSON-serializable value)","error response if validation or execution fails"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_7","uri":"capability://tool.use.integration.resource.capability.definition.with.static.and.dynamic.uris","name":"resource capability definition with static and dynamic uris","description":"Resources are MCP capabilities that represent data sources with static or dynamic URIs. The Resource class encapsulates a URI template, description, MIME type, and a handler that reads or lists resource content. Resources support URI templates with variables (e.g., 'file://{path}') that are resolved at runtime. The ResourceTemplate class enables parameterized resource definitions where clients can request resources with specific parameters. When a client calls resources/read or resources/list, the handler resolves the URI, fetches content, and returns it with the specified MIME type.","intents":["I want to expose files, API endpoints, or database records as MCP resources","I need to support parameterized resource access (e.g., read file at path {path})","I want to list available resources with their URIs and descriptions"],"best_for":["developers exposing file systems, APIs, or databases as MCP resources","teams building AI agents that need read-only access to external data","applications requiring URI-based resource addressing"],"limitations":["Resources are read-only in the current SDK — no write/update operations","URI templates are limited to simple variable substitution — no complex path matching","Resource listing may be slow for large datasets — no built-in pagination"],"requires":["PHP 8.1+","resource handler (callable that returns content)","URI template (string with optional {variable} placeholders)"],"input_types":["resource URI (string)","URI parameters (key-value pairs)","MIME type specification"],"output_types":["resource content (string or binary)","MIME type (e.g., 'text/plain', 'application/json')","resource list with URIs and descriptions"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_8","uri":"capability://text.generation.language.prompt.capability.definition.with.template.arguments","name":"prompt capability definition with template arguments","description":"Prompts are MCP capabilities that represent template-based prompt generators with arguments. The Prompt class encapsulates a name, description, arguments schema, and a handler that generates prompt text based on provided arguments. Prompts support parameterized templates where clients can request prompt generation with specific argument values. When a client calls prompts/get, the handler receives the arguments, generates the prompt text, and returns it as content. Prompts can be defined via attributes (#[McpPrompt]) with automatic schema generation from method signatures.","intents":["I want to provide reusable prompt templates that AI clients can customize with arguments","I need to generate context-specific prompts based on client-provided parameters","I want to expose prompt generation logic as an MCP capability"],"best_for":["developers building AI agents that need dynamic prompt generation","teams providing prompt libraries as MCP services","applications requiring context-aware prompt customization"],"limitations":["Prompts are text-only — no support for structured prompt formats","Argument validation is schema-based — complex validation must be in the handler","No built-in prompt caching or versioning"],"requires":["PHP 8.1+","prompt handler (callable that returns prompt text)","arguments schema (JSON Schema, auto-generated from attributes or manual)"],"input_types":["prompt name (string)","arguments (JSON object)","argument schema (JSON Schema)"],"output_types":["prompt text (string)","error response if validation or generation fails"],"categories":["text-generation-language","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-php-mcp-sdk__cap_9","uri":"capability://data.processing.analysis.json.schema.validation.and.generation.from.php.types","name":"json schema validation and generation from php types","description":"The SDK uses opis/json-schema for validating MCP request arguments against capability schemas, and phpdocumentor/reflection-docblock for generating schemas from PHP method signatures and DocBlocks. The SchemaGenerator component parses type hints (scalar, class, union types) and PHPDoc annotations to produce JSON Schema objects that describe tool/resource/prompt arguments. This enables automatic schema generation from attributes without manual schema writing, with support for complex types like arrays, objects, and nullable types.","intents":["I want to generate JSON Schema from PHP method signatures automatically","I need to validate tool arguments against schemas before execution","I want to ensure argument types match PHP method signatures"],"best_for":["developers using PHP type hints and wanting automatic schema generation","teams needing strict argument validation before capability execution","applications requiring OpenAPI/JSON Schema documentation from code"],"limitations":["Schema generation is limited to PHPDoc format — non-standard documentation won't be captured","Complex nested types may require manual schema refinement","Generic types (e.g., List<T>) are not fully supported — requires manual schema definition"],"requires":["PHP 8.1+","opis/json-schema for validation","phpdocumentor/reflection-docblock for parsing","type hints in method signatures"],"input_types":["PHP method signatures with type hints","PHPDoc comments","JSON Schema definitions"],"output_types":["JSON Schema objects","validation results (pass/fail with error details)"],"categories":["data-processing-analysis","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":29,"verified":false,"data_access_risk":"high","permissions":["PHP 8.1+ (attributes introduced in PHP 8.0)","phpdocumentor/reflection-docblock dependency","PSR-4 autoloading for class discovery","PHP 8.1+","psr/container implementation for dependency injection","symfony/uid for session ID generation","exception handling in capability handlers","error code mapping configuration","JSON-RPC 2.0 compliant client","request handlers for each MCP method"],"failure_modes":["DocBlock parsing is limited to PHPDoc format — non-standard documentation won't be captured","Complex nested types in method signatures may require manual schema refinement","Attribute discovery requires explicit class scanning — no automatic file globbing without Symfony Finder integration","Builder state is mutable — no immutability guarantees if builder is reused after build()","Complex capability registration logic must be expressed through method chaining, which can become verbose for 50+ capabilities","No built-in validation of capability conflicts or duplicate registrations until build() is called","Error messages may expose internal details if not carefully filtered","Custom exception types must be explicitly mapped to MCP error codes","No built-in error logging — must be implemented separately","Protocol routing is synchronous — no built-in async request handling","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.6,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:04.047Z","last_scraped_at":"2026-05-03T14:00:18.053Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=php-mcp-sdk","compare_url":"https://unfragile.ai/compare?artifact=php-mcp-sdk"}},"signature":"oX82ygSPVQ3o2ReQPBFRhtWImC/l37xUu/Ubi+CEGmHwd9tlrrhDnYkEEF3UDIFVSg1QI2Ro/KpdGMmMUarvAA==","signedAt":"2026-06-21T10:25:54.436Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/php-mcp-sdk","artifact":"https://unfragile.ai/php-mcp-sdk","verify":"https://unfragile.ai/api/v1/verify?slug=php-mcp-sdk","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}