Embabel Agent Platform Auto-Configuration

<dependency>
    <groupId>com.embabel.agent</groupId>
    <artifactId>embabel-agent-platform-autoconfigure</artifactId>
    <version>0.3.3</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Add Spring AI model provider (required) -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
</dependency>

# application.properties
spring.ai.openai.api-key=your-api-key
spring.ai.openai.chat.options.model=gpt-4

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
import com.embabel.agent.autoconfigure.platform.AgentPlatformAutoConfiguration;

@SpringBootApplication
@ImportAutoConfiguration(AgentPlatformAutoConfiguration.class)
public class AgentApplication {
    public static void main(String[] args) {
        SpringApplication.run(AgentApplication.class, args);
    }
}

embabel.agent.logging.personality=starwars

@AutoConfiguration
@ImportAutoConfiguration({QuiteMcpClientAutoConfiguration.class})
@Import({CommonPlatformPropertiesLoader.class, ScanConfiguration.class,
         AgentPlatformConfiguration.class, ToolGroupsConfiguration.class})
public class AgentPlatformAutoConfiguration {
    // Automatically discovered by Spring Boot
}

@AutoConfiguration
@ConditionalOnClass(McpSchema.class)
@ConditionalOnProperty(prefix = "spring.ai.mcp.client", name = "enabled",
                       havingValue = "true", matchIfMissing = true)
public class QuiteMcpClientAutoConfiguration extends McpClientAutoConfiguration {

    @Bean
    @ConditionalOnProperty(prefix = "spring.ai.mcp.client", name = "type",
                           havingValue = "SYNC", matchIfMissing = true)
    List<McpSyncClient> mcpSyncClients(...);

    @Bean
    @ConditionalOnProperty(prefix = "spring.ai.mcp.client", name = "type",
                           havingValue = "ASYNC")
    List<McpAsyncClient> mcpAsyncClients(...);
}

// Logging theme
@ConfigurationProperties(prefix = "embabel.agent.logging")
record LoggingPersonalityProperties(String personality) {}

// MCP client (from Spring AI)
class McpClientCommonProperties {
    boolean enabled;              // Default: true
    String type;                  // SYNC or ASYNC, default: SYNC
    String name;                  // Client name
    String version;               // Client version
    Duration requestTimeout;      // Request timeout
    boolean initialized;          // Auto-initialize, default: true
}

@SpringBootApplication
public class MyAgentApp {
    public static void main(String[] args) {
        SpringApplication.run(MyAgentApp.class, args);
    }
}

spring.ai.openai.api-key=sk-...
embabel.agent.logging.personality=starwars

spring.ai.mcp.client.enabled=true
spring.ai.mcp.client.type=SYNC
spring.ai.mcp.client.name=my-agent
spring.ai.mcp.client.version=1.0.0
spring.ai.mcp.client.request-timeout=10s
spring.ai.mcp.client.initialized=true

import io.modelcontextprotocol.client.McpSyncClient;
import org.springframework.beans.factory.annotation.Autowired;

@Service
public class MyService {
    @Autowired
    private List<McpSyncClient> mcpClients;

    public void useClient() {
        if (!mcpClients.isEmpty()) {
            McpSyncClient client = mcpClients.get(0);
            // Use client...
        }
    }
}

@SpringBootApplication(exclude = {AgentPlatformAutoConfiguration.class})
public class MyApp { }

spring.autoconfigure.exclude=\
  com.embabel.agent.autoconfigure.platform.AgentPlatformAutoConfiguration

spring.ai.mcp.client.enabled=false

spring.ai.mcp.client.type=ASYNC

import io.modelcontextprotocol.client.McpAsyncClient;
import reactor.core.publisher.Mono;

@Service
public class MyReactiveService {
    @Autowired
    private List<McpAsyncClient> mcpAsyncClients;

    public Mono<Void> useClientAsync() {
        if (!mcpAsyncClients.isEmpty()) {
            McpAsyncClient client = mcpAsyncClients.get(0);
            // Use reactive client...
        }
        return Mono.empty();
    }
}

# Choose one theme
embabel.agent.logging.personality=starwars
embabel.agent.logging.personality=severance
embabel.agent.logging.personality=colossus
embabel.agent.logging.personality=hitchhiker
embabel.agent.logging.personality=montypython

@Value("${embabel.agent.logging.personality:}")
private String theme;

# application.yml
spring:
  profiles:
    active: dev

---
spring:
  config:
    activate:
      on-profile: dev
embabel:
  agent:
    logging:
      personality: starwars

---
spring:
  config:
    activate:
      on-profile: prod
embabel:
  agent:
    logging:
      personality: ""

// Main auto-configuration
@AutoConfiguration
public class AgentPlatformAutoConfiguration {
    // Imports: QuiteMcpClientAutoConfiguration, ScanConfiguration,
    //          AgentPlatformConfiguration, ToolGroupsConfiguration
}

// Component scanning
@Configuration
@ComponentScan(basePackages = {"com.embabel.agent.*"})
@ConfigurationPropertiesScan(basePackages = {"com.embabel.agent.*"})
public class ScanConfiguration {
}

// MCP client auto-configuration
@AutoConfiguration
@ConditionalOnClass(McpSchema.class)
@ConditionalOnProperty(prefix = "spring.ai.mcp.client", name = "enabled",
                       havingValue = "true", matchIfMissing = true)
public class QuiteMcpClientAutoConfiguration extends McpClientAutoConfiguration {

    List<McpSyncClient> mcpSyncClients(
        McpSyncClientConfigurer configurer,
        McpClientCommonProperties properties,
        ObjectProvider<List<NamedClientMcpTransport>> transports,
        ObjectProvider<ClientMcpSyncHandlersRegistry> handlers
    );

    List<McpAsyncClient> mcpAsyncClients(
        McpAsyncClientConfigurer configurer,
        McpClientCommonProperties properties,
        ObjectProvider<List<NamedClientMcpTransport>> transports,
        ObjectProvider<ClientMcpAsyncHandlersRegistry> handlers
    );
}

// Auto-configuration filter
public class AgentPlatformAutoConfigurationFilter
    implements AutoConfigurationImportFilter {

    boolean[] match(String[] autoConfigurationClasses,
                    AutoConfigurationMetadata metadata);
    // Excludes: org.springframework.ai.mcp.client.common.autoconfigure.McpClientAutoConfiguration
}

// Environment post-processor
public class EnvironmentPostProcessor
    implements org.springframework.boot.env.EnvironmentPostProcessor,
               org.springframework.core.Ordered {

    String LOGGING_THEME_PROPERTY = "embabel.agent.logging.personality";

    void postProcessEnvironment(ConfigurableEnvironment environment,
                                SpringApplication application);

    int getOrder(); // Returns Ordered.HIGHEST_PRECEDENCE
}

// Configuration properties
@ConfigurationProperties(prefix = "embabel.agent.logging")
record LoggingPersonalityProperties(String personality) {}

class McpClientCommonProperties {
    boolean enabled;
    String type;
    String name;
    String version;
    Duration requestTimeout;
    boolean initialized;
}

// MCP client types
interface McpSyncClient {
    void initialize();
}

interface McpAsyncClient {
    Mono<Void> initialize();
}

@SpringBootApplication
@EnableAgents(
    loggingTheme = LoggingThemes.STAR_WARS,
    mcpServers = {"filesystem"}
)
public class OldApp { }

@SpringBootApplication
@ImportAutoConfiguration(AgentPlatformAutoConfiguration.class)
public class NewApp { }

embabel.agent.logging.personality=starwars

ERROR c.e.a.a.p.QuiteMcpClientAutoConfiguration -
Failed to initialize MCP Sync Client: my-client - Application startup will continue