{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"awesome-spring-ai-mcp-client","slug":"spring-ai-mcp-client","name":"Spring AI MCP Client","type":"mcp","url":"https://docs.spring.io/spring-ai/reference/api/mcp/mcp-client-boot-starter-docs.html","page_url":"https://unfragile.ai/spring-ai-mcp-client","categories":["mcp-servers"],"tags":[],"pricing":{"model":"unknown","free":false,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"awesome-spring-ai-mcp-client__cap_0","uri":"capability://automation.workflow.spring.boot.auto.configuration.for.mcp.client.initialization","name":"spring boot auto-configuration for mcp client initialization","description":"Automatically configures and instantiates MCP client beans in Spring Boot applications through convention-over-configuration patterns, eliminating manual bean definition boilerplate. Uses Spring's @EnableAutoConfiguration mechanism to detect MCP client starter on classpath and apply sensible defaults (20s request timeout, SYNC client type, auto-initialization enabled) while allowing override via spring.ai.mcp.client.* properties. Supports both standard JDK HttpClient and WebFlux-based transports, with automatic selection based on which starter dependency is present.","intents":["I want to add MCP client support to my Spring Boot app without writing configuration classes","I need sensible defaults for MCP client behavior but want to override specific settings via application.yml","I'm choosing between standard and WebFlux implementations and want the right one selected automatically"],"best_for":["Spring Boot developers building LLM-integrated applications","Teams standardizing on Spring AI framework for MCP connectivity","Developers wanting zero-config MCP client setup with optional customization"],"limitations":["Auto-configuration applies globally — cannot have different client types (SYNC vs ASYNC) in same application","Configuration is property-driven only; programmatic bean customization requires implementing Spring's Customizer pattern","WebFlux starter required for production high-concurrency scenarios; standard starter may bottleneck under load"],"requires":["Spring Boot 2.7+ (version not explicitly stated but implied by Spring AI framework requirements)","spring-ai-starter-mcp-client or spring-ai-starter-mcp-client-webflux on classpath","Java 11+ runtime environment"],"input_types":["YAML/properties configuration files","Environment variables (spring.ai.mcp.client.* pattern)"],"output_types":["Configured MCP client bean instances","Spring ApplicationContext with MCP client registered"],"categories":["automation-workflow","spring-boot-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-spring-ai-mcp-client__cap_1","uri":"capability://tool.use.integration.multi.transport.mcp.connectivity.with.pluggable.implementations","name":"multi-transport mcp connectivity with pluggable implementations","description":"Provides abstracted transport layer supporting STDIO (in-process command execution), SSE (Server-Sent Events over HTTP), and Streamable-HTTP variants, with implementation swapped between standard JDK HttpClient and Spring WebFlux based on starter dependency. Each transport is configured independently via spring.ai.mcp.client.[transport-type].* properties, allowing single application to connect to multiple MCP servers via different transports. STDIO transport executes local commands directly; HTTP transports use streaming to handle long-running MCP operations without blocking.","intents":["I need to connect to MCP servers running as local processes via STDIO and remote servers via HTTP in the same app","I want to use WebFlux for high-concurrency HTTP connections to MCP servers in production","I need to configure different timeouts and connection parameters for different transport types"],"best_for":["Polyglot MCP deployments mixing local and remote server connections","High-concurrency production systems requiring non-blocking HTTP transports","Microservices architectures where some MCP servers are co-located and others are remote"],"limitations":["STDIO transport limited to local process execution — no network isolation or sandboxing","Cannot mix SYNC and ASYNC client types globally; transport choice does not override this constraint","HTTP transports require MCP server to support SSE or Streamable-HTTP protocols; legacy STDIO-only servers cannot be accessed via HTTP","WebFlux transport adds dependency on Spring WebFlux (reactor-core, netty) — increases application footprint"],"requires":["For STDIO: executable MCP server binary accessible from application classpath/PATH","For HTTP/SSE: MCP server with HTTP endpoint supporting SSE or Streamable-HTTP protocol","spring-ai-starter-mcp-client-webflux for production HTTP scenarios (standard starter uses blocking JDK HttpClient)"],"input_types":["STDIO: command string and arguments","HTTP: URL endpoint, optional authentication headers"],"output_types":["MCP protocol messages (JSON-RPC 2.0 format)","Tool definitions and resource metadata from connected servers"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-spring-ai-mcp-client__cap_10","uri":"capability://automation.workflow.client.initialization.control.and.lifecycle.hooks","name":"client initialization control and lifecycle hooks","description":"Provides spring.ai.mcp.client.initialized property (default true) to control whether MCP clients are automatically initialized when created. When true, clients connect to servers immediately; when false, clients are created but not initialized, allowing application to control initialization timing. This enables lazy initialization patterns and deferred connection establishment. Lifecycle hooks (specific hook names not documented) allow applications to react to client initialization events.","intents":["I want to defer MCP client connection until my application is fully initialized","I need to control when MCP clients connect to servers based on application state","I want to implement lazy initialization of MCP clients to reduce startup time"],"best_for":["Applications with complex startup sequences where MCP connection timing matters","Systems with optional MCP functionality that should not block startup","Deployments where MCP servers may not be available at application startup"],"limitations":["Initialization control is global — cannot defer initialization for specific clients","Lifecycle hook patterns not documented — unclear how to register initialization handlers","No explicit initialization API documented — unclear how to manually initialize deferred clients","Deferred initialization may complicate debugging if clients are not initialized when expected"],"requires":["spring.ai.mcp.client.initialized property set to false to defer initialization","Manual initialization code (API not documented)","Lifecycle hook registration mechanism (not documented)"],"input_types":["Initialization control flag (true/false)"],"output_types":["Deferred or immediate MCP client initialization","Lifecycle events on initialization completion"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-spring-ai-mcp-client__cap_11","uri":"capability://automation.workflow.client.identity.configuration.with.name.and.version","name":"client identity configuration with name and version","description":"Allows configuration of MCP client identity through spring.ai.mcp.client.name (default 'spring-ai-mcp-client') and spring.ai.mcp.client.version (default '1.0.0') properties. These values are sent to MCP servers as part of client initialization, allowing servers to identify and potentially customize behavior based on client identity. Version string enables servers to implement version-specific compatibility logic or feature detection.","intents":["I want MCP servers to identify my application by a custom name","I need to communicate my application version to MCP servers for compatibility checking","I want servers to implement version-specific behavior based on my client version"],"best_for":["Applications with custom branding or identity requirements","Systems where MCP servers need to identify client applications","Deployments using multiple client versions requiring server-side compatibility logic"],"limitations":["Client identity is static — cannot change name/version at runtime","Identity is global — all MCP client instances report same name/version","No standard for how servers use client identity — behavior is server-dependent","Version string is free-form — no semantic versioning validation or compatibility checking"],"requires":["spring.ai.mcp.client.name property (string, default 'spring-ai-mcp-client')","spring.ai.mcp.client.version property (string, default '1.0.0')"],"input_types":["Client name string","Client version string"],"output_types":["Client identity sent to MCP servers during initialization","Server responses potentially customized based on client identity"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-spring-ai-mcp-client__cap_2","uri":"capability://automation.workflow.declarative.mcp.server.configuration.via.json.or.properties","name":"declarative mcp server configuration via json or properties","description":"Enables configuration of multiple named MCP server connections through either a centralized JSON configuration file (spring.ai.mcp.client.stdio.servers-configuration property) or inline properties map (spring.ai.mcp.client.stdio.connections.[name].command). Each named connection specifies the command to execute (for STDIO) or endpoint URL (for HTTP transports), and can be referenced by name throughout the application. Supports environment variable interpolation and Spring property placeholder syntax, allowing externalized secrets and environment-specific configuration.","intents":["I want to define multiple MCP server connections in application.yml without code changes","I need to externalize MCP server commands/URLs to environment variables for different deployment environments","I want a single JSON file listing all MCP servers my application connects to, with version control and audit trail"],"best_for":["DevOps teams managing multi-environment deployments (dev/staging/prod with different MCP servers)","Applications connecting to 3+ MCP servers where centralized configuration is clearer than scattered properties","Organizations requiring configuration audit trails and version-controlled server definitions"],"limitations":["JSON configuration file path must be absolute or relative to application classpath — no dynamic discovery of configuration files","Property-based configuration limited to flat key-value structure — complex per-server settings (timeouts, retries, auth) not shown in documentation","No built-in validation of server configurations at startup — invalid commands/URLs only fail when client attempts connection","Configuration is static at application startup — adding new MCP servers requires application restart"],"requires":["For JSON config: valid JSON file at path specified in spring.ai.mcp.client.stdio.servers-configuration","For properties config: spring.ai.mcp.client.stdio.connections.[name].command property defined","Spring property resolution enabled (default in Spring Boot)"],"input_types":["JSON file with server definitions","YAML/properties with spring.ai.mcp.client.* keys","Environment variables referenced via ${ENV_VAR} syntax"],"output_types":["Named MCP client connections registered in Spring context","Resolved command strings or URLs ready for transport layer"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-spring-ai-mcp-client__cap_3","uri":"capability://tool.use.integration.selective.tool.exposure.via.filtering.and.name.prefixing","name":"selective tool exposure via filtering and name-prefixing","description":"Filters which tools exposed by connected MCP servers are made available to Spring AI's tool execution framework, and optionally prefixes tool names to avoid naming collisions when multiple servers expose tools with identical names. Filtering logic is applied during client initialization based on configuration (specific mechanism not detailed in documentation), and prefixing uses customizable prefix generation strategy. This prevents tool namespace pollution and allows applications to selectively enable/disable tools without modifying server configuration.","intents":["I have multiple MCP servers exposing tools with the same name and need to disambiguate them in my LLM prompts","I want to disable certain dangerous or unused tools from a connected MCP server without modifying the server itself","I need to expose only a subset of tools from a large MCP server to reduce LLM context and improve inference speed"],"best_for":["Applications connecting to multiple MCP servers with overlapping tool namespaces","Security-conscious deployments restricting tool access based on application role/context","LLM-driven applications optimizing for inference latency by limiting tool availability"],"limitations":["Tool filtering configuration syntax not documented — unclear how to specify include/exclude rules","Name prefix generation strategy not documented — unclear if prefixes are auto-generated or user-specified","Filtering applied at client initialization only — cannot dynamically enable/disable tools at runtime","No per-request tool filtering — all requests see the same filtered tool set"],"requires":["Tool filtering configuration properties (exact property names not documented)","Understanding of tool names exposed by connected MCP servers"],"input_types":["Tool filter configuration (format unknown)","Tool name prefix strategy configuration (format unknown)"],"output_types":["Filtered tool registry available to Spring AI","Tool names with optional prefixes applied"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-spring-ai-mcp-client__cap_4","uri":"capability://tool.use.integration.spring.ai.tool.execution.framework.integration.via.callbacks","name":"spring ai tool execution framework integration via callbacks","description":"Integrates MCP client tools with Spring AI's tool execution framework through a callback mechanism (spring.ai.mcp.client.toolcallback.enabled property controls this). When enabled, tools discovered from connected MCP servers are automatically registered as Spring AI ToolCallback implementations, allowing LLMs to invoke them through Spring AI's standard tool-calling APIs. The integration handles marshaling of tool inputs/outputs between Spring AI's type system and MCP protocol format, abstracting transport and serialization details.","intents":["I want LLMs in my Spring AI application to call tools from MCP servers using standard Spring AI tool-calling APIs","I need tools from multiple MCP servers to appear as a unified tool registry to my LLM","I want to use Spring AI's tool execution features (caching, retry, monitoring) with MCP server tools"],"best_for":["Spring AI developers building LLM agents with tool-calling capabilities","Applications using Spring AI's ChatClient or other LLM interfaces that support tool calling","Teams standardizing on Spring AI framework and wanting MCP tools to integrate seamlessly"],"limitations":["Tool callback integration only works with Spring AI framework — cannot use MCP tools with other LLM frameworks without additional adapters","Callback mechanism details not documented — unclear how tool inputs are validated or how errors are handled","No explicit caching of tool results — each tool invocation goes to MCP server (may add latency for repeated calls)","Tool callback integration disabled by default (spring.ai.mcp.client.toolcallback.enabled defaults to true but can be disabled)"],"requires":["Spring AI framework with tool-calling support","spring.ai.mcp.client.toolcallback.enabled=true in configuration","At least one MCP server connected with tools exposed"],"input_types":["Tool invocation requests from Spring AI ChatClient","Tool input parameters in Spring AI's type system"],"output_types":["Tool execution results in Spring AI ToolCallback format","Structured tool responses ready for LLM consumption"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-spring-ai-mcp-client__cap_5","uri":"capability://automation.workflow.annotation.based.mcp.client.discovery.and.handler.registration","name":"annotation-based mcp client discovery and handler registration","description":"Provides annotation-based mechanism (spring.ai.mcp.client.annotation-scanner.enabled controls this) to auto-discover and register MCP client handlers in Spring applications. Annotations allow developers to mark methods or classes as MCP handlers, which are automatically detected during component scanning and registered with the MCP client. This enables declarative, code-first approach to MCP integration without explicit bean configuration. Specific annotation names and handler patterns not documented, but mechanism integrates with Spring's @Component scanning.","intents":["I want to define MCP handlers using annotations rather than configuration files","I need to auto-discover MCP handlers across my codebase without manually registering each one","I want to use Spring's standard component scanning to find and initialize MCP handlers"],"best_for":["Spring developers preferring annotation-driven configuration over XML or properties","Modular applications where MCP handlers are scattered across multiple packages","Teams using Spring's component scanning extensively and wanting consistency"],"limitations":["Annotation-based handler patterns not documented — unclear what annotations are available or how to use them","Handler implementation details not specified — unclear what methods/classes can be annotated","Annotation scanner enabled by default but can be disabled — requires understanding when to disable it","No documentation on handler lifecycle or error handling in annotated handlers"],"requires":["spring.ai.mcp.client.annotation-scanner.enabled=true (default)","Spring component scanning enabled (@ComponentScan or Spring Boot default)","Specific MCP handler annotations (names and usage patterns not documented)"],"input_types":["Java classes/methods with MCP handler annotations"],"output_types":["Registered MCP handler beans in Spring context","Handlers available for MCP client to invoke"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-spring-ai-mcp-client__cap_6","uri":"capability://automation.workflow.synchronous.and.asynchronous.mcp.client.implementations.with.global.type.constraint","name":"synchronous and asynchronous mcp client implementations with global type constraint","description":"Provides both SYNC and ASYNC client implementations (controlled via spring.ai.mcp.client.type property), allowing applications to choose between blocking and non-blocking MCP operations. However, the client type is global — all MCP client instances in an application must use the same type (cannot mix SYNC and ASYNC). SYNC clients block on MCP operations; ASYNC clients return CompletableFuture or reactive types. This constraint simplifies threading model and prevents complex async/sync bridging logic.","intents":["I want to use non-blocking async MCP operations in my reactive Spring application","I need blocking synchronous MCP calls in a traditional servlet-based Spring application","I want to ensure consistent threading behavior across all MCP client instances"],"best_for":["Reactive Spring applications (WebFlux) using ASYNC client type","Traditional servlet-based Spring applications using SYNC client type","Teams wanting to enforce consistent async/sync patterns across MCP usage"],"limitations":["Global client type constraint — cannot have both SYNC and ASYNC clients in same application","No per-connection type override — all connections must use application-wide type","Mixing SYNC and ASYNC requires separate application instances or architectural refactoring","SYNC client may block thread pools in high-concurrency scenarios — WebFlux starter recommended for production"],"requires":["spring.ai.mcp.client.type property set to SYNC or ASYNC (default: SYNC)","For ASYNC: understanding of CompletableFuture or reactive types (Mono/Flux if using WebFlux)"],"input_types":["MCP operation requests (blocking or async depending on client type)"],"output_types":["SYNC: direct return values from MCP operations","ASYNC: CompletableFuture or reactive types (Mono/Flux)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-spring-ai-mcp-client__cap_7","uri":"capability://automation.workflow.configurable.request.timeout.and.lifecycle.management","name":"configurable request timeout and lifecycle management","description":"Provides configurable request timeout (spring.ai.mcp.client.request-timeout property, default 20 seconds) for all MCP operations, and automatic lifecycle management that cleans up resources when Spring ApplicationContext closes. Timeout applies globally to all MCP operations; individual operation timeouts not supported. Lifecycle management ensures proper shutdown of transport connections and cleanup of thread pools without requiring explicit shutdown code.","intents":["I need to set a global timeout for all MCP operations to prevent hanging requests","I want to adjust timeout for slow MCP servers or high-latency networks","I need assurance that MCP client resources are properly cleaned up when my application shuts down"],"best_for":["Applications with strict latency requirements or SLAs","Deployments with unreliable MCP servers that may hang","Production systems requiring proper resource cleanup on shutdown"],"limitations":["Timeout is global — cannot set different timeouts for different MCP servers or operations","No per-operation timeout override — all operations use same timeout value","Timeout applies to entire operation including network latency — cannot distinguish between slow server and slow network","No timeout configuration for specific operation types (tool calls vs resource access)"],"requires":["spring.ai.mcp.client.request-timeout property (duration format, e.g., '20s', '30000ms')","Spring ApplicationContext lifecycle management (automatic in Spring Boot)"],"input_types":["Timeout duration in Spring duration format"],"output_types":["Timeout exceptions when operations exceed configured duration","Proper resource cleanup on application shutdown"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-spring-ai-mcp-client__cap_8","uri":"capability://automation.workflow.root.change.notifications.for.mcp.resource.updates","name":"root change notifications for mcp resource updates","description":"Enables root change notifications (spring.ai.mcp.client.root-change-notification property, default true) to receive updates when MCP server's resource roots change. When enabled, client listens for root change events from connected servers and triggers application-level handlers. This allows applications to react to changes in available resources (e.g., new files added to a watched directory) without polling. Notification mechanism and handler registration patterns not documented.","intents":["I want my application to react when an MCP server's available resources change","I need to invalidate cached resource metadata when a server notifies of root changes","I want to trigger re-indexing or re-discovery of resources when an MCP server updates"],"best_for":["Applications caching MCP resource metadata that needs invalidation on updates","Systems monitoring file systems or other dynamic resources via MCP servers","Event-driven architectures reacting to resource availability changes"],"limitations":["Root change notification handler patterns not documented — unclear how to register handlers","Notification mechanism not specified — unclear if notifications are pushed or pulled","No filtering of root change notifications — application receives all changes from all servers","Enabled by default but can be disabled — requires understanding when to disable for performance"],"requires":["spring.ai.mcp.client.root-change-notification=true (default)","MCP servers that support root change notifications","Handler registration mechanism (not documented)"],"input_types":["Root change events from MCP servers"],"output_types":["Application-level notifications/events triggered by root changes","Updated resource metadata from servers"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-spring-ai-mcp-client__cap_9","uri":"capability://automation.workflow.customizable.client.creation.through.spring.customizer.pattern","name":"customizable client creation through spring customizer pattern","description":"Allows customization of MCP client bean creation through Spring's Customizer pattern (implementing MCP client Customizer interface), enabling post-configuration modifications without overriding auto-configuration. Customizers are applied after auto-configuration creates the client bean, allowing fine-grained control over client properties, transport settings, or handler registration. Multiple customizers can be registered and are applied in order. This pattern integrates with Spring Boot's customization conventions.","intents":["I need to customize MCP client configuration beyond what properties support","I want to programmatically register custom handlers or interceptors on the MCP client","I need to apply environment-specific customizations without overriding auto-configuration"],"best_for":["Advanced Spring Boot developers needing fine-grained client customization","Applications with complex MCP client setup that properties cannot express","Teams building reusable Spring Boot starters that customize MCP clients"],"limitations":["Customizer interface and methods not documented — unclear what customizations are possible","Customizers applied after auto-configuration — cannot override core auto-configuration decisions","No ordering guarantee for multiple customizers — order of application not specified","Customizer pattern requires Java code — cannot be expressed in configuration files"],"requires":["Implementation of MCP client Customizer interface (interface definition not provided)","Registration of customizer as Spring bean (via @Bean or @Component)","Understanding of MCP client API (not documented)"],"input_types":["MCP client bean created by auto-configuration"],"output_types":["Customized MCP client bean with modifications applied"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":28,"verified":false,"data_access_risk":"high","permissions":["Spring Boot 2.7+ (version not explicitly stated but implied by Spring AI framework requirements)","spring-ai-starter-mcp-client or spring-ai-starter-mcp-client-webflux on classpath","Java 11+ runtime environment","For STDIO: executable MCP server binary accessible from application classpath/PATH","For HTTP/SSE: MCP server with HTTP endpoint supporting SSE or Streamable-HTTP protocol","spring-ai-starter-mcp-client-webflux for production HTTP scenarios (standard starter uses blocking JDK HttpClient)","spring.ai.mcp.client.initialized property set to false to defer initialization","Manual initialization code (API not documented)","Lifecycle hook registration mechanism (not documented)","spring.ai.mcp.client.name property (string, default 'spring-ai-mcp-client')"],"failure_modes":["Auto-configuration applies globally — cannot have different client types (SYNC vs ASYNC) in same application","Configuration is property-driven only; programmatic bean customization requires implementing Spring's Customizer pattern","WebFlux starter required for production high-concurrency scenarios; standard starter may bottleneck under load","STDIO transport limited to local process execution — no network isolation or sandboxing","Cannot mix SYNC and ASYNC client types globally; transport choice does not override this constraint","HTTP transports require MCP server to support SSE or Streamable-HTTP protocols; legacy STDIO-only servers cannot be accessed via HTTP","WebFlux transport adds dependency on Spring WebFlux (reactor-core, netty) — increases application footprint","Initialization control is global — cannot defer initialization for specific clients","Lifecycle hook patterns not documented — unclear how to register initialization handlers","No explicit initialization API documented — unclear how to manually initialize deferred clients","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.34,"ecosystem":0.25,"match_graph":0.25,"freshness":0.75,"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.049Z","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=spring-ai-mcp-client","compare_url":"https://unfragile.ai/compare?artifact=spring-ai-mcp-client"}},"signature":"RBqkMuvubwoPOeRGLmee8770YCi7eq3tMfe9W/A9LKqbQLkkaeTpiGAIqlqeVvMGpZWrX8c4ZFcPKXFukNqYDg==","signedAt":"2026-06-22T16:53:57.121Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/spring-ai-mcp-client","artifact":"https://unfragile.ai/spring-ai-mcp-client","verify":"https://unfragile.ai/api/v1/verify?slug=spring-ai-mcp-client","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"}}