Build AI Applications with Spring AI (Fu Cheng)（Z-Library）

# Build AI Applications with Spring AI — Reading Guide ## 【One-Line Pitch】 A practical, code-first guide for Java developers who want to build AI-powered applications using Spring AI 1.1.0, covering everything from chat completions and streaming to RAG pipelines and vector stores. If you're a Spring Boot developer looking to integrate LLMs into your existing stack, this book is your hands-on roadmap. ## 【Book Arc】 - **Opening (~0%–10%)**: Sets up the development environment — Java 17+ (recommended Java 21/25 for virtual threads), Spring AI 1.1.0 with Maven and the spring-ai-bom, and local LLM setup using Docker with models like Qwen3-0.6B. Establishes the core abstractions: ModelRequest, ModelResponse, and the generic model API. - **Early (~10%–23%)**: Dives into chat completion fundamentals — ChatOptions (temperature, topP, maxTokens, stop sequences), Generation and ChatResponseMetadata (rate limits, finish reasons), and the fluent ChatClient API for building prompts. Introduces PromptTemplate with TemplateRenderer for dynamic prompt rendering and the Advisor chain for intercepting requests/responses. - **Early (~23%–32%)**: Explores advanced chat patterns — advisor ordering with Spring's Ordered interface, recursive advisors (new in 1.1) for agent loops like evaluator-optimizer, and streaming chat with Server-Sent Events (SSE) including event types like MessageStreamingStartEvent and TokenUsageEvent. - **Early (~32%–39%)**: Covers structured output conversion — ListOutputConverter, MapOutputConverter, and BeanOutputConverter for turning LLM text responses into typed Java objects using Spring's ConversionService. - **Middle (~39%–48%)**: Shifts to RAG fundamentals — embedding models (EmbeddingModel, EmbeddingOptions, BatchingStrategy), document handling (TextReader, JsonReader, Document Transformer/Writer), and vector stores as the semantic backbone for similarity search. - **Middle (~48%–end)**: Completes the RAG picture — vector store operations (add, delete, similarity search), filter expressions (Filter.Expression with AND/OR composition), SimpleVectorStore and Pgvector implementations, cloud vector store options, and the full RAG pipeline from simple to modular architectures (query, pre-retrieval, retrieval, post-retrieval, generation). ## 【Key Takeaways】 - **Java 17+ with virtual threads is the baseline** (Opening): Spring AI 1.1.0 requires Java 17 minimum, but Java 21/25 unlocks virtual threads for better concurrency. Use the spring-ai-bom for dependency management to avoid version conflicts. - **ChatClient is the primary entry point** (Early): The fluent API lets you build prompts with user/system messages, set options, and call or stream responses. You can pass an existing Prompt object or build one inline with methods like `user()`, `system()`, and `options()`. - **Advisors enable cross-cutting concerns** (Early): The Advisor chain runs before and after model calls, perfect for logging, caching, or modifying requests. Order matters — use values greater than 0 to avoid conflicts with built-in advisors. Spring AI 1.1's recursive advisors enable repeated execution for agent patterns. - **Streaming requires SSE and event handling** (Early): Use Flux<ServerSentEvent> for real-time chat responses. The event stream includes start/complete markers and token usage events, letting you build responsive UIs with JavaScript's EventSource. - **Structured output converters tame LLM responses** (Early): ListOutputConverter, MapOutputConverter, and BeanOutputConverter transform free-text LLM output into typed Java objects, making AI responses safe to use in business logic. - **RAG reduces hallucinations by grounding responses** (Middle): Convert documents to embeddings, store them in a vector store, retrieve similar content at query time, and combine with a prompt template that instructs the model to answer from provided context only. - **Vector stores are the backbone of RAG** (Middle): Documents are stored as vectors, not raw text. Filter expressions (e.g., source=db AND lastUpdatedAt>yesterday) let you narrow searches. SimpleVectorStore works for testing; Pgvector and cloud services scale to production. - **Document readers handle multiple formats** (Middle): TextReader and JsonReader parse resources into Document objects, with JsonMetadataGenerator for enriching metadata. This is the ingestion layer that feeds your vector store. ## 【Reading Tips】 - **Skim the environment setup (Opening)**: If you already have Java and Docker, jump straight to the chat completion chapters. The Docker Compose for local LLM serving is useful but not the core value. - **Deep-read the ChatClient and Advisor chapters (Early)**: These are the most reusable patterns. The logging advisor example is worth copying verbatim — it's a debugging lifesaver for seeing exactly what goes to and from the model. - **Pay attention to the streaming event model (Early)**: The four-event sequence (start, deltas, token usage, complete) is a clean pattern you'll want to replicate. Don't skip the HTML/JavaScript example — it shows the full client-server loop. - **Focus on the RAG pipeline chapters (Middle)**: The progression from naive to modular RAG is the book's payoff. Understand the pre-retrieval (query rewriting), retrieval (vector search), and post-retrieval (reranking) stages before implementing. - **Use the code samples as templates**: The REST controllers for vector stores and streaming are production-ready patterns. Adapt them rather than writing from scratch. ## 【Coverage Limits】 This guide covers the book's core content on chat completion, streaming, structured output, and RAG with vector stores. Excerpts do not cover image understanding, advanced agent patterns, or cloud deployment specifics in detail — those sections are listed in the table of contents but not sampled here. ##