The Spring ecosystem, and what Spring AI can do now.

Spring Boot 1.0 answered the question every Spring project had been asking since 2004: why does it take a day of XML to serve one HTTP endpoint? Auto-configuration inspects the classpath and configures what it finds; starters bundle coherent dependency sets; the embedded server turns a web application into a process you start with java -jar. Actuator shipped in 1.0 too, which is why health and metrics endpoints are a Spring reflex rather than an afterthought.

@SpringBootApplication                       // @Configuration + @EnableAutoConfiguration + @ComponentScan
public class Application {
    public static void main(String[] args) { SpringApplication.run(Application.class, args); }
}

@RestController
class HelloController {
    @RequestMapping("/") String hello() { return "Hello from Spring Boot 1.0"; }
}

Boot 2.0 arrived alongside Spring Framework 5 and made Java 8 the minimum, so lambdas and functional bean registration became idiomatic. WebFlux offered a non-blocking stack for the cases that needed it, and Micrometer became the metrics facade, which is how Spring applications learned to speak Prometheus. Spring Boot 2.3 later added buildpack images, layered jars and graceful shutdown; 2.4 through 2.7 refined configuration processing and Java 17 support while 3.0 was being prepared.

@RestController
class QuoteController {
    private final WebClient client = WebClient.create("https://api.example.com");

    @GetMapping("/quotes/{isin}")
    Mono<Quote> quote(@PathVariable String isin) {          // non-blocking end to end
        return client.get().uri("/quotes/{isin}", isin).retrieve().bodyToMono(Quote.class);
    }
}

Boot 3.0 was the largest migration since 2.0: Java 17 became the floor, every javax.* import became jakarta.*, and GraalVM native compilation went from experiment to supported feature, with start-up in tens of milliseconds. The Micrometer Observation API unified metrics and tracing so a single annotation produces both. Spring Boot 3.2 (November 2023) then delivered the operational win of the generation: virtual threads for Tomcat and every task executor with one property, plus RestClient and JdbcClient as synchronous, fluent replacements for RestTemplate and JdbcTemplate.

# application.properties, Spring Boot 3.2+
spring.threads.virtual.enabled=true          # Tomcat, @Async, @Scheduled and task executors on virtual threads
management.tracing.sampling.probability=1.0  # Micrometer Tracing: one trace per request in dev

@Service
class PricingService {
    private final RestClient rest;
    private final JdbcClient jdbc;

    PricingService(RestClient.Builder builder, JdbcClient jdbc) {
        this.rest = builder.baseUrl("https://rates.example.com").build();
        this.jdbc = jdbc;
    }

    @Observed(name = "pricing.quote")                       // metrics + trace span from one annotation
    Quote quote(String isin) {
        BigDecimal rate = rest.get().uri("/fx/CHF").retrieve().body(BigDecimal.class);   // blocking, on a virtual thread
        return jdbc.sql("select price from quotes where isin = :isin")
                   .param("isin", isin)
                   .query((rs, i) -> new Quote(isin, rs.getBigDecimal("price").multiply(rate)))
                   .single();
    }
}

Boot 4.0 is the current generation. The codebase was split into focused modules so an application pulls only what it uses. JSpecify annotations across the portfolio give IDEs and Kotlin precise nullability. Jackson 3 is the JSON library. Spring Framework 7 brought three things teams had been building by hand: first-class API versioning in Spring MVC and WebFlux, declarative HTTP service clients with auto-configured groups, and resilience annotations (@Retryable, @ConcurrencyLimit) in the core rather than in a separate project. Spring Boot 4.1 (June 2026) added Spring gRPC support, an SSRF mitigation filter for HTTP clients and updated OpenTelemetry support; 4.2 is in milestones.

// API versioning: the same handler class, two contract versions
@RestController
@RequestMapping("/accounts")
class AccountController {
    @GetMapping(path = "/{id}", version = "1")
    AccountV1 v1(@PathVariable String id) { return service.v1(id); }

    @GetMapping(path = "/{id}", version = "2")                 // clients send X-API-Version: 2 or ?version=2
    AccountV2 v2(@PathVariable String id) { return service.v2(id); }
}

// HTTP service client: an interface, no implementation, auto-configured by Boot 4
@HttpExchange("/fx")
interface RatesClient {
    @GetExchange("/{currency}")
    BigDecimal rate(@PathVariable String currency);
}

@Service
class QuoteService {
    private final RatesClient rates;
    QuoteService(RatesClient rates) { this.rates = rates; }

    @Retryable(maxAttempts = 3, delay = 200)                   // Spring Framework 7 core resilience (@EnableResilientMethods)
    @ConcurrencyLimit(20)                                      // at most 20 concurrent calls into the rates API
    BigDecimal chf(String currency) { return rates.rate(currency); }
}

# application.properties, Spring Boot 4
spring.http.client.service.group.rates.base-url=https://rates.example.com
spring.http.client.service.group.rates.read-timeout=2s
spring.threads.virtual.enabled=true

ChatClient is the front door: a fluent API in the style of RestClient, built from an auto-configured builder for whichever provider is on the classpath. The same code runs against Anthropic, OpenAI, Amazon Bedrock, Google GenAI, Mistral, DeepSeek or a local Ollama model; the provider is a dependency and a property, not a code path.

<!-- pom.xml: Spring AI 2.0 BOM plus the Anthropic starter -->
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.ai</groupId>
      <artifactId>spring-ai-bom</artifactId>
      <version>2.0.1</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-starter-model-anthropic</artifactId>
</dependency>

# application.properties
spring.ai.anthropic.api-key=${ANTHROPIC_API_KEY}
spring.ai.anthropic.chat.model=claude-sonnet-5        # Spring AI 2.0 dropped the extra ".options" segment

@RestController
class AskController {
    private final ChatClient chat;

    AskController(ChatClient.Builder builder) {
        this.chat = builder
            .defaultSystem("You are the support assistant for a Swiss fasting app. Answer in the user's language, briefly.")
            .build();
    }

    @GetMapping("/ask")
    String ask(@RequestParam String q) {
        return chat.prompt().user(q).call().content();
    }

    @GetMapping(value = "/ask/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    Flux<String> stream(@RequestParam String q) {
        return chat.prompt().user(q).stream().content();      // tokens as they arrive
    }
}

A model's text answer becomes a Java object with .entity(). Spring AI generates a JSON schema from the record, instructs the model to fill it, and maps the response. In 2.0 you can ask the provider to enforce the schema natively and validate the result; a StructuredOutputValidationAdvisor can also repair non-conforming JSON automatically.

record Triage(String category, int priority, List<String> nextSteps) {}

Triage triage = chat.prompt()
    .system("Classify support tickets for a banking app. Priority 1 is highest.")
    .user(ticketText)
    .call()
    .entity(Triage.class, spec -> spec
        .useProviderStructuredOutput()                        // the provider's native JSON schema mode
        .validateSchema());                                   // reject anything that does not match

A @Tool method is a Java method the model may ask to run. Spring AI sends its name, description and parameter schema to the model, executes the call when the model requests it, feeds the result back, and repeats until the model answers. In 2.0 that loop is a ToolCallingAdvisor in the advisor chain, so it is one composable, observable component rather than logic buried in each provider. ToolSearchToolCallingAdvisor indexes a large tool set and lets the model discover only the tools it needs.

@Component
class AccountTools {
    private final AccountRepository accounts;
    AccountTools(AccountRepository accounts) { this.accounts = accounts; }

    @Tool(description = "Get the current balance of an account, in CHF")
    BigDecimal balance(@ToolParam(description = "IBAN of the account") String iban) {
        return accounts.balance(iban);
    }

    @Tool(description = "Block a card. Requires an explicit customer request. Returns the case number.")
    String blockCard(@ToolParam(description = "last four digits") String last4,
                     @ToolParam(description = "reason given by the customer") String reason) {
        return accounts.blockCard(last4, reason);            // the policy check lives here, not in the prompt
    }
}

@Service
class AssistantService {
    private final ChatClient chat;
    AssistantService(ChatClient.Builder builder, AccountTools tools) {
        this.chat = builder.defaultTools(tools).build();      // the tool loop is automatic in 2.0
    }
    String handle(String message) {
        return chat.prompt().user(message).call().content();
    }
}

Advisors are middleware for prompts: each one can read and rewrite the request and the response. Memory, retrieval, guardrails and logging are all advisors, which keeps business code free of them. The memory advisor stores turns per conversation ID in an in-memory, JDBC, Cassandra or Neo4j store, and the window implementation caps how many turns are replayed.

@Configuration
class ChatConfig {
    @Bean
    ChatClient supportChat(ChatClient.Builder builder, ChatMemory memory) {   // ChatMemory auto-configured, JDBC-backed with the starter
        return builder
            .defaultAdvisors(
                MessageChatMemoryAdvisor.builder(memory).build(),
                SafeGuardAdvisor.builder().sensitiveWords(List.of("password", "PIN")).build(),
                new SimpleLoggerAdvisor())
            .build();
    }
}

// per call: the conversation ID selects the memory
String answer = supportChat.prompt()
    .user(message)
    .advisors(a -> a.param(ChatMemory.CONVERSATION_ID, sessionId))
    .call()
    .content();

Retrieval-augmented generation in Spring AI is an ETL pipeline plus one advisor. Readers (PDF, Tika for Office formats, JSON, Markdown) produce documents; a splitter chunks them; an embedding model turns chunks into vectors; a VectorStore stores them. Twenty stores are supported, from pgvector and Redis to Pinecone, Qdrant, Weaviate, MongoDB Atlas and Oracle. At query time QuestionAnswerAdvisor retrieves the best chunks and appends them to the prompt.

@Service
class PolicyIngest {
    private final VectorStore store;
    PolicyIngest(VectorStore store) { this.store = store; }         // pgvector via spring-ai-starter-vector-store-pgvector

    void ingest(Resource pdf) {
        List<Document> pages  = new PagePdfDocumentReader(pdf).get();
        List<Document> chunks = new TokenTextSplitter().apply(pages);
        store.add(chunks);                                           // embeds and stores in one call
    }
}

@Service
class PolicyAnswers {
    private final ChatClient chat;
    PolicyAnswers(ChatClient.Builder builder, VectorStore store) {
        this.chat = builder
            .defaultAdvisors(QuestionAnswerAdvisor.builder(store)
                .searchRequest(SearchRequest.builder().topK(4).similarityThreshold(0.7).build())
                .build())
            .build();
    }
    String answer(String question) {
        return chat.prompt().user(question).call().content();       // grounded in the retrieved chunks
    }
}

Spring AI 2.0 ships the MCP Java SDK 2.0 and puts the annotation model in core. A Spring service becomes an MCP server by annotating methods with @McpTool, @McpResource or @McpPrompt; Streamable HTTP is the default transport, with OAuth 2.0 and OpenTelemetry supported out of the box. On the other side, an MCP client connects to any server (yours, a vendor's, or a desktop tool's) and its tools appear to the ChatClient like local ones.

// MCP server: spring-ai-starter-mcp-server-webmvc
@Component
class CalendarMcp {
    @McpTool(name = "free-slots", description = "Free 30-minute slots for a person on a given day")
    List<String> freeSlots(@McpToolParam(description = "email") String person,
                           @McpToolParam(description = "ISO date") LocalDate day) {
        return calendar.freeSlots(person, day);
    }
}

# MCP client: spring-ai-starter-mcp-client, connect to two servers
spring.ai.mcp.client.streamable-http.connections.calendar.url=http://calendar.internal:8080
spring.ai.mcp.client.streamable-http.connections.docs.url=http://docs.internal:8080

@Service
class Scheduler {
    private final ChatClient chat;
    Scheduler(ChatClient.Builder builder, ToolCallbackProvider mcpTools) {    // every tool from every connected server
        this.chat = builder.defaultToolCallbacks(mcpTools).build();
    }
    String plan(String request) { return chat.prompt().user(request).call().content(); }
}

Spring AI has evaluators that use a model to grade a model: RelevancyEvaluator checks that an answer is relevant to the question and the retrieved context, FactCheckingEvaluator checks claims against the context. They run in ordinary tests. At runtime, every ChatClient call, tool call, embedding and vector search emits Micrometer observations, so token usage, latency and error rates are on the same dashboards as the rest of the service.

@SpringBootTest
class PolicyAnswersTest {
    @Autowired ChatClient.Builder builder;
    @Autowired VectorStore store;
    @Autowired PolicyAnswers answers;

    @Test
    void answerIsRelevantAndGrounded() {
        String question = "How many days do I have to report a lost card?";
        String answer   = answers.answer(question);
        List<Document> context = store.similaritySearch(SearchRequest.builder().query(question).topK(4).build());

        var evaluator = new RelevancyEvaluator(builder);
        EvaluationResponse result = evaluator.evaluate(new EvaluationRequest(question, context, answer));

        assertThat(result.isPass()).as(result.getFeedback()).isTrue();
    }
}

Spring AI does not impose an agent framework; it gives you the primitives and documents the five patterns that cover most production agents: prompt chaining, routing, parallelisation, orchestrator-workers and evaluator-optimiser. Each is a few lines of ordinary Java over ChatClient, which means each is testable and debuggable like any other service method. The community spring-ai-agent-utils project adds reusable Agent Skills, and spring-ai-session adds event-sourced conversation memory with model-driven compaction.

// Evaluator-optimiser: draft, grade, revise, stop when good enough
record Grade(boolean pass, String feedback) {}

String draftAndRefine(String brief) {
    String draft = chat.prompt().user("Write a customer notice: " + brief).call().content();
    for (int round = 0; round < 3; round++) {
        Grade grade = chat.prompt()
            .system("You review customer notices for a Swiss bank. Pass only if it is accurate, calm and under 120 words.")
            .user("Brief: " + brief + "\n\nNotice:\n" + draft)
            .call().entity(Grade.class);
        if (grade.pass()) return draft;
        draft = chat.prompt().user("Revise this notice. Feedback: " + grade.feedback() + "\n\n" + draft).call().content();
    }
    throw new IllegalStateException("could not produce an acceptable notice");   // a human takes over
}