Chat Infrastructure Modules

/**
 * Autoconfigures ChatClient.Builder for fluent chat interactions
 * 
 * Conditional Requirements:
 * - @ConditionalOnClass: org.springframework.ai.chat.client.ChatClient
 * - @ConditionalOnProperty: spring.ai.chat.client.enabled=true (default)
 * 
 * @AutoConfiguration
 * @ConditionalOnClass(ChatClient.class)
 * @EnableConfigurationProperties(ChatClientBuilderProperties.class)
 */
@AutoConfiguration
@ConditionalOnClass(ChatClient.class)
@EnableConfigurationProperties(ChatClientBuilderProperties.class)
class ChatClientAutoConfiguration {
    // Bean definitions for chat client
}

/**
 * Creates ChatClient.Builder bean
 * Builder pattern for creating ChatClient instances with fluent API
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @param chatModel The underlying chat model (OpenAI, Anthropic, etc.)
 * @return ChatClient.Builder for creating ChatClient instances
 */
@Bean
@ConditionalOnMissingBean
ChatClient.Builder chatClientBuilder(ChatModel chatModel);

/**
 * Properties for ChatClient configuration
 */
class ChatClientBuilderProperties {
    /** Enable/disable chat client (default: true) */
    private boolean enabled = true;
    
    /** Log prompt content in observations (default: false) */
    private boolean logPrompt = false;
    
    /** Log completion content in observations (default: false) */
    private boolean logCompletion = false;
}

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.stereotype.Service;

@Service
public class ChatService {
    private final ChatClient chatClient;
    
    public ChatService(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder
            .defaultSystem("You are a helpful assistant")
            .build();
    }
    
    public String chat(String message) {
        return chatClient.prompt()
            .user(message)
            .call()
            .content();
    }
}

/**
 * Autoconfigures core chat memory support
 * 
 * Conditional Requirements:
 * - @ConditionalOnClass: ChatMemory, ChatMemoryRepository
 * 
 * @AutoConfiguration
 * @ConditionalOnClass({ChatMemory.class, ChatMemoryRepository.class})
 */
@AutoConfiguration
@ConditionalOnClass({ChatMemory.class, ChatMemoryRepository.class})
class ChatMemoryAutoConfiguration {
    // Bean definitions for chat memory
}

/**
 * Creates default in-memory ChatMemory implementation
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @param repository Storage backend for conversation history
 * @return ChatMemory implementation
 */
@Bean
@ConditionalOnMissingBean
ChatMemory chatMemory(ChatMemoryRepository repository);

/**
 * Creates default ChatMemoryRepository if none provided
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @return In-memory ChatMemoryRepository
 */
@Bean
@ConditionalOnMissingBean
ChatMemoryRepository chatMemoryRepository();

/**
 * Autoconfigures Cassandra-backed chat memory repository
 * 
 * Conditional Requirements:
 * - @ConditionalOnClass: CassandraChatMemoryRepository, CqlSession
 * 
 * @AutoConfiguration(after = CassandraAutoConfiguration.class, 
 *                    before = ChatMemoryAutoConfiguration.class)
 * @ConditionalOnClass({CassandraChatMemoryRepository.class, CqlSession.class})
 */
@AutoConfiguration(after = CassandraAutoConfiguration.class, 
                   before = ChatMemoryAutoConfiguration.class)
@ConditionalOnClass({CassandraChatMemoryRepository.class, CqlSession.class})
class CassandraChatMemoryRepositoryAutoConfiguration {
    // Bean definitions for Cassandra repository
}

/**
 * Creates Cassandra chat memory repository
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @param session Cassandra CQL session
 * @return ChatMemoryRepository backed by Cassandra
 */
@Bean
@ConditionalOnMissingBean
ChatMemoryRepository cassandraChatMemoryRepository(CqlSession session);

# Configuration prefix: spring.ai.chat.memory.repository.cassandra
# No specific properties - uses Spring Boot's Cassandra configuration

/**
 * Autoconfigures Azure Cosmos DB-backed chat memory repository
 * 
 * Conditional Requirements:
 * - @ConditionalOnClass: CosmosDBChatMemoryRepository, CosmosAsyncClient
 * - @ConditionalOnProperty: spring.ai.chat.memory.repository.cosmosdb.endpoint
 * 
 * @AutoConfiguration
 * @ConditionalOnClass({CosmosDBChatMemoryRepository.class, CosmosAsyncClient.class})
 */
@AutoConfiguration
@ConditionalOnClass({CosmosDBChatMemoryRepository.class, CosmosAsyncClient.class})
class CosmosDBChatMemoryRepositoryAutoConfiguration {
    // Bean definitions for Cosmos DB repository
}

/**
 * Creates Cosmos DB async client
 * 
 * @Bean
 * @ConditionalOnProperty(prefix = "spring.ai.chat.memory.repository.cosmosdb", 
 *                        name = "endpoint")
 * @param properties Cosmos DB configuration properties
 * @return CosmosAsyncClient for Cosmos DB access
 */
@Bean
@ConditionalOnProperty(prefix = "spring.ai.chat.memory.repository.cosmosdb", 
                       name = "endpoint")
CosmosAsyncClient cosmosAsyncClient(CosmosDBChatMemoryRepositoryProperties properties);

/**
 * Creates Cosmos DB chat memory repository
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @param client Cosmos DB async client
 * @return ChatMemoryRepository backed by Cosmos DB
 */
@Bean
@ConditionalOnMissingBean
ChatMemoryRepository cosmosDbChatMemoryRepository(CosmosAsyncClient client);

spring.ai.chat.memory.repository.cosmosdb.endpoint=https://your-account.documents.azure.com:443/
spring.ai.chat.memory.repository.cosmosdb.key=your-key
spring.ai.chat.memory.repository.cosmosdb.database=chat-db
spring.ai.chat.memory.repository.cosmosdb.container=conversations

/**
 * Autoconfigures JDBC-backed chat memory repository
 * 
 * Conditional Requirements:
 * - @ConditionalOnClass: JdbcChatMemoryRepository, DataSource, JdbcTemplate
 * 
 * @AutoConfiguration(after = JdbcTemplateAutoConfiguration.class,
 *                    before = ChatMemoryAutoConfiguration.class)
 * @ConditionalOnClass({JdbcChatMemoryRepository.class, DataSource.class, JdbcTemplate.class})
 */
@AutoConfiguration(after = JdbcTemplateAutoConfiguration.class,
                   before = ChatMemoryAutoConfiguration.class)
@ConditionalOnClass({JdbcChatMemoryRepository.class, DataSource.class, JdbcTemplate.class})
class JdbcChatMemoryRepositoryAutoConfiguration {
    // Bean definitions for JDBC repository
}

/**
 * Creates JDBC chat memory repository
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @param jdbcTemplate Spring JDBC template
 * @return ChatMemoryRepository backed by JDBC
 */
@Bean
@ConditionalOnMissingBean
ChatMemoryRepository jdbcChatMemoryRepository(JdbcTemplate jdbcTemplate);

class JdbcChatMemoryRepositoryProperties {
    /** Initialize schema on startup (default: EMBEDDED) */
    private DatabaseInitializationMode initializeSchema = DatabaseInitializationMode.EMBEDDED;

    /** Schema DDL script locations (comma-separated) */
    private String schema = "classpath:org/springframework/ai/chat/memory/jdbc/schema-@@platform@@.sql";

    /** Platform identifier for schema scripts */
    private String platform = "auto-detected";
}

/**
 * Specialized schema initializer for JDBC chat memory tables
 * Extends Spring Boot's DataSourceScriptDatabaseInitializer
 * Supports database-specific SQL scripts via platform detection
 */
class JdbcChatMemoryRepositorySchemaInitializer
    extends DataSourceScriptDatabaseInitializer

# ALWAYS - Always initialize schema on startup
spring.ai.chat.memory.repository.jdbc.initialize-schema=always

# EMBEDDED - Initialize only for embedded databases (H2, HSQLDB) - Default
spring.ai.chat.memory.repository.jdbc.initialize-schema=embedded

# NEVER - Never initialize schema (assume tables exist)
spring.ai.chat.memory.repository.jdbc.initialize-schema=never

# Custom schema location
spring.ai.chat.memory.repository.jdbc.schema=classpath:my-custom-schema.sql

/**
 * Autoconfigures MongoDB-backed chat memory repository
 * 
 * Conditional Requirements:
 * - @ConditionalOnClass: MongoChatMemoryRepository, MongoTemplate
 * 
 * @AutoConfiguration(before = ChatMemoryAutoConfiguration.class)
 * @ConditionalOnClass({MongoChatMemoryRepository.class, MongoTemplate.class})
 */
@AutoConfiguration(before = ChatMemoryAutoConfiguration.class)
@ConditionalOnClass({MongoChatMemoryRepository.class, MongoTemplate.class})
class MongoChatMemoryAutoConfiguration {
    // Bean definitions for MongoDB repository
}

/**
 * Creates MongoDB chat memory repository
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @param mongoTemplate Spring Data MongoDB template
 * @return ChatMemoryRepository backed by MongoDB
 */
@Bean
@ConditionalOnMissingBean
ChatMemoryRepository mongoChatMemoryRepository(MongoTemplate mongoTemplate);

class MongoChatMemoryProperties {
    /** Create indices automatically (default: false) */
    private boolean createIndices = false;

    /** TTL for conversation documents (default: 0 = no expiration) */
    private Duration ttl = Duration.ZERO;
}

/**
 * Autoconfigures MongoDB index creation for chat memory collections
 * Separate from repository configuration for clean separation of concerns
 *
 * Conditional Requirements:
 * - @ConditionalOnClass: MongoChatMemoryRepository, MongoTemplate
 * - @ConditionalOnProperty: spring.ai.chat.memory.repository.mongo.create-indices=true
 * 
 * @AutoConfiguration
 */
@AutoConfiguration
class MongoChatMemoryIndexCreatorAutoConfiguration {
    // Bean definitions for index creation
}

/**
 * Creates MongoDB index creator
 * 
 * @Bean
 * @ConditionalOnProperty(prefix = "spring.ai.chat.memory.repository.mongo",
 *                        name = "create-indices", havingValue = "true")
 * @param mongoTemplate MongoDB template
 * @param properties MongoDB chat memory properties
 * @return Index creator for MongoDB collections
 */
@Bean
@ConditionalOnProperty(prefix = "spring.ai.chat.memory.repository.mongo",
                       name = "create-indices", havingValue = "true")
MongoIndexCreator mongoIndexCreator(MongoTemplate mongoTemplate,
                                    MongoChatMemoryProperties properties);

# Enable automatic index creation
spring.ai.chat.memory.repository.mongo.create-indices=true

# Set TTL for automatic document expiration
spring.ai.chat.memory.repository.mongo.ttl=24h

/**
 * Autoconfigures Neo4j-backed chat memory repository
 * 
 * Conditional Requirements:
 * - @ConditionalOnClass: Neo4jChatMemoryRepository, Driver
 * 
 * @AutoConfiguration(after = Neo4jAutoConfiguration.class,
 *                    before = ChatMemoryAutoConfiguration.class)
 * @ConditionalOnClass({Neo4jChatMemoryRepository.class, org.neo4j.driver.Driver.class})
 */
@AutoConfiguration(after = Neo4jAutoConfiguration.class,
                   before = ChatMemoryAutoConfiguration.class)
@ConditionalOnClass({Neo4jChatMemoryRepository.class, org.neo4j.driver.Driver.class})
class Neo4jChatMemoryRepositoryAutoConfiguration {
    // Bean definitions for Neo4j repository
}

/**
 * Creates Neo4j chat memory repository
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @param driver Neo4j driver
 * @return ChatMemoryRepository backed by Neo4j
 */
@Bean
@ConditionalOnMissingBean
ChatMemoryRepository neo4jChatMemoryRepository(org.neo4j.driver.Driver driver);

/**
 * Autoconfigures observation/monitoring for chat operations
 * Integrates with Spring Boot Actuator for metrics and tracing
 * 
 * Conditional Requirements:
 * - @ConditionalOnClass: ChatModel
 * 
 * @AutoConfiguration
 * @ConditionalOnClass(ChatModel.class)
 * @EnableConfigurationProperties(ChatObservationProperties.class)
 */
@AutoConfiguration
@ConditionalOnClass(ChatModel.class)
@EnableConfigurationProperties(ChatObservationProperties.class)
class ChatObservationAutoConfiguration {
    // Bean definitions for chat observation
}

/**
 * Observation handler for chat model operations
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @return Handler for chat observations
 */
@Bean
@ConditionalOnMissingBean
ChatModelObservationHandler chatModelObservationHandler();

/**
 * Metrics handler for chat operations
 * Requires MeterRegistry
 * 
 * @Bean
 * @ConditionalOnBean(MeterRegistry.class)
 * @param registry Metrics registry
 * @return Metrics handler for chat operations
 */
@Bean
@ConditionalOnBean(MeterRegistry.class)
ChatModelMeterObservationHandler chatModelMeterObservationHandler(MeterRegistry registry);

/**
 * Prompt content logging handler
 * Only created when logPrompt=true
 * 
 * @Bean
 * @ConditionalOnProperty(prefix = "spring.ai.chat.observations", 
 *                        name = "log-prompt", havingValue = "true")
 * @ConditionalOnClass(Tracer.class)
 * @ConditionalOnBean(Tracer.class)
 * @return Handler for logging prompt content
 */
@Bean
@ConditionalOnProperty(prefix = "spring.ai.chat.observations", 
                       name = "log-prompt", havingValue = "true")
@ConditionalOnClass(Tracer.class)
@ConditionalOnBean(Tracer.class)
ChatModelPromptContentObservationHandler chatModelPromptContentObservationHandler();

class ChatObservationProperties {
    /** Log prompt content in observations (default: false) */
    private boolean logPrompt = false;
    
    /** Log completion content in observations (default: false) */
    private boolean logCompletion = false;
    
    /** Include error logging in observations (default: false) */
    private boolean includeErrorLogging = false;
}

spring.ai.chat.observations.log-prompt=true
spring.ai.chat.observations.log-completion=true
spring.ai.chat.observations.include-error-logging=true

# Enable actuator endpoints
management.endpoints.web.exposure.include=health,metrics,prometheus
management.metrics.export.prometheus.enabled=true
management.tracing.enabled=true

/**
 * Autoconfigures observation for embedding operations
 * 
 * Conditional Requirements:
 * - @ConditionalOnClass: EmbeddingModel
 * 
 * @AutoConfiguration
 * @ConditionalOnClass(EmbeddingModel.class)
 */
@AutoConfiguration
@ConditionalOnClass(EmbeddingModel.class)
class EmbeddingObservationAutoConfiguration {
    // Bean definitions for embedding observation
}

/**
 * Observation handler for embedding operations
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @return Handler for embedding observations
 */
@Bean
@ConditionalOnMissingBean
EmbeddingModelObservationHandler embeddingModelObservationHandler();

/**
 * Metrics handler for embedding operations
 * 
 * @Bean
 * @ConditionalOnBean(MeterRegistry.class)
 * @param registry Metrics registry
 * @return Metrics handler for embeddings
 */
@Bean
@ConditionalOnBean(MeterRegistry.class)
EmbeddingModelMeterObservationHandler embeddingModelMeterObservationHandler(
    MeterRegistry registry
);

/**
 * Autoconfigures observation for image generation operations
 * 
 * Conditional Requirements:
 * - @ConditionalOnClass: ImageModel
 * 
 * @AutoConfiguration
 * @ConditionalOnClass(ImageModel.class)
 * @EnableConfigurationProperties(ImageObservationProperties.class)
 */
@AutoConfiguration
@ConditionalOnClass(ImageModel.class)
@EnableConfigurationProperties(ImageObservationProperties.class)
class ImageObservationAutoConfiguration {
    // Bean definitions for image observation
}

/**
 * Observation handler for image operations
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @return Handler for image observations
 */
@Bean
@ConditionalOnMissingBean
ImageModelObservationHandler imageModelObservationHandler();

/**
 * Prompt content logging for image operations
 * 
 * @Bean
 * @ConditionalOnProperty(prefix = "spring.ai.image.observations", 
 *                        name = "log-prompt", havingValue = "true")
 * @ConditionalOnClass(Tracer.class)
 * @ConditionalOnBean(Tracer.class)
 * @return Handler for logging image prompts
 */
@Bean
@ConditionalOnProperty(prefix = "spring.ai.image.observations", 
                       name = "log-prompt", havingValue = "true")
@ConditionalOnClass(Tracer.class)
@ConditionalOnBean(Tracer.class)
ImageModelPromptContentObservationHandler imageModelPromptContentObservationHandler();

class ImageObservationProperties {
    /** Log prompt content for image generation (default: false) */
    private boolean logPrompt = false;
}

/**
 * Autoconfigures tool calling/function calling support
 * 
 * Conditional Requirements:
 * - @ConditionalOnClass: ChatModel
 * 
 * @AutoConfiguration
 * @ConditionalOnClass(ChatModel.class)
 * @EnableConfigurationProperties(ToolCallingProperties.class)
 */
@AutoConfiguration
@ConditionalOnClass(ChatModel.class)
@EnableConfigurationProperties(ToolCallingProperties.class)
class ToolCallingAutoConfiguration {
    // Bean definitions for tool calling
}

/**
 * Creates FunctionCallbackContext for managing function callbacks
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @param applicationContext Spring application context
 * @return Context for function callbacks
 */
@Bean
@ConditionalOnMissingBean
FunctionCallbackContext functionCallbackContext(ApplicationContext applicationContext);

/**
 * Wrapper for FunctionCallback beans
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @param context Function callback context
 * @return Wrapper for function callbacks
 */
@Bean
@ConditionalOnMissingBean
FunctionCallbackWrapper functionCallbackWrapper(FunctionCallbackContext context);

/**
 * Registry for discovering and managing tool callbacks
 * 
 * @Bean
 * @ConditionalOnMissingBean
 * @param functionCallbacks List of function callbacks
 * @param context Function callback context
 * @return Registry for tool callbacks
 */
@Bean
@ConditionalOnMissingBean
ToolCallbackRegistry toolCallbackRegistry(
    List<FunctionCallback> functionCallbacks,
    FunctionCallbackContext context
);

/**
 * Observation handler for tool calling operations
 * Includes tool call content in observations when enabled
 * 
 * @Bean
 * @ConditionalOnProperty(prefix = "spring.ai.tools.observations", 
 *                        name = "include-content", havingValue = "true")
 * @return Handler for tool call observations
 */
@Bean
@ConditionalOnProperty(prefix = "spring.ai.tools.observations", 
                       name = "include-content", havingValue = "true")
ToolCallContentObservationHandler toolCallContentObservationHandler();

class ToolCallingProperties {
    /** Throw exception on tool execution error (default: false) */
    private boolean throwExceptionOnError = false;
    
    /** Observation configuration */
    private Observations observations = new Observations();
    
    static class Observations {
        /** Include tool call content in observations (default: false) */
        private boolean includeContent = false;
    }
}

import org.springframework.ai.model.function.FunctionCallback;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ToolsConfig {
    
    @Bean
    public FunctionCallback weatherTool() {
        return FunctionCallback.builder()
            .function("get_weather", (WeatherRequest request) -> {
                return new WeatherResponse(
                    request.location(),
                    "Sunny",
                    72
                );
            })
            .description("Get current weather for a location")
            .inputType(WeatherRequest.class)
            .build();
    }
    
    record WeatherRequest(String location) {}
    record WeatherResponse(String location, String condition, int temperature) {}
}

@Service
public class AssistantService {
    private final ChatClient chatClient;
    
    public AssistantService(ChatClient.Builder builder) {
        this.chatClient = builder
            .defaultFunctions("get_weather") // Reference tool by name
            .build();
    }
    
    public String chat(String message) {
        // AI can automatically call tools as needed
        return chatClient.prompt()
            .user(message)
            .call()
            .content();
    }
}

# application.yml
spring:
  ai:
    # Chat client
    chat:
      client:
        enabled: true
        log-prompt: false
        log-completion: false
      
      # Chat memory with MongoDB
      memory:
        repository:
          mongo:
            create-indices: true
            ttl: 24h
      
      # Chat observations
      observations:
        log-prompt: true
        log-completion: false
        include-error-logging: true
    
    # Tool calling
    tools:
      throw-exception-on-error: false
      observations:
        include-content: true
    
    # Image observations
    image:
      observations:
        log-prompt: true
    
    # Provider configuration (example: OpenAI)
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-4
          temperature: 0.7

# Actuator configuration for observations
management:
  endpoints:
    web:
      exposure:
        include: health,metrics,prometheus
  metrics:
    export:
      prometheus:
        enabled: true
  tracing:
    enabled: true
    sampling:
      probability: 1.0

# application.properties

# Enable JDBC chat memory
spring.ai.chat.memory.repository.jdbc.initialize-schema=always
spring.ai.chat.memory.repository.jdbc.platform=postgresql

# Database configuration
spring.datasource.url=jdbc:postgresql://localhost:5432/chatdb
spring.datasource.username=user
spring.datasource.password=pass