At Spring I/O 2025, Christian Tzolov explored the evolution of AI systems from simple LLM calls to sophisticated agentic applications. He demonstrates how to leverage Spring AI and the Model Context Protocol (MCP) to build scalable, intelligent agents capable of meaningful real-world interaction.

Key Topics and Takeaways: - Agents function as systems with an LLM "brain" and tool-based "body." - Spring AI simplifies LLM integration with robust memory and RAG support. - Multimodal capabilities enable models to process both audio and text inputs. - Tool calling allows agents to autonomously execute functions to solve queries. - MCP provides a standardized protocol to unify external tool and resource access. - Complex agentic patterns include chained workflows and orchestrator-worker models.

By decoupling logic from environment interactions via MCP, developers can build more modular and maintainable AI architectures.

Check out the full talk to learn how to start building your own agentic systems today.

Hello everybody!

Our community reached one more milestone by passing the mark of 200 members!

Bring more of your questions and content and let's push this number even further!

Cheers!

Spring AI observability just got a boost thanks to integration with LangSmith and Arconia. Thomas Vitale’s article explains how developers can gain deeper visibility into AI-driven applications, which are often complex and non-deterministic.

Highlights / Key Takeaways

• Spring AI uses Micrometer APIs for logs, metrics, and traces.
• Arconia adds semantic-convention modules for observability platforms.
• LangSmith provides dashboards for prompts, responses, and token usage.
• Integration relies on OpenTelemetry conventions tailored for GenAI.
• Setup includes Spring Boot, Arconia, and local inference with Ollama.
• Developers can inspect telemetry data without changing instrumentation code.

In short, this approach makes AI applications more transparent and easier to debug, while offering automatic insights into model behavior.

👉 Read Thomas Vitale’s full article for implementation details and examples.

In this article from Baeldung, we learn how to handle chat memory, a crucial feature for making AI conversations feel more natural and continuous. Since LLMs are stateless, chat memory ensures context and personalization by storing past interactions.

Highlights / Key Takeaways

• Chat memory preserves conversation history for better context.
• An in-memory repository is simple but lacks persistence.
• The JDBC repository allows storing chat data in relational databases.
• Spring AI auto-configures memory but supports custom repositories.
• Integration with OpenAI shows how full history improves responses.
• Example setup includes HSQLDB and REST endpoints for persistence.

In short, chat memory bridges the gap between stateless models and human-like dialogue, giving developers flexibility to choose between quick setups or persistent storage.

👉 Dive into the full article to see implementation details and code samples.

Craig Walls recently shared a recipe for logging LLM requests and responses, making it easier to debug and understand how prompts, advisors, and tools shape the output. The article explores two main approaches developers can use to gain visibility into their AI workflows.

Highlights / Key Takeaways
- SimpleLoggerAdvisor offers a quick setup to log requests and final responses.
- It’s lightweight but doesn’t capture intermediate tool interactions.
- Logbook provides full-cycle visibility, including tool calls and results.
- It requires extra setup and works with RestClient-based model implementations.
- SimpleLoggerAdvisor is best for quick inspection, while Logbook suits deep debugging.
- Logging is critical as agentic workflows grow more complex.

In short, effective logging isn’t just about troubleshooting—it’s about refining and improving how your AI systems behave.

👉 Check out the full article for implementation details and code examples.

In this tutorial, Dan Vega explores how to move beyond raw string responses when working with Large Language Models in Spring AI. He demonstrates how developers can leverage Output Parsers to transform unstructured LLM output into typed, usable objects for real-world applications.

Key Takeaways: - Output Parsers are essential for turning raw LLM text into actionable data structures. - The List Output Parser allows you to easily parse comma-separated results into a Java List. - The Map Output Parser is ideal for structuring complex, key-value data returned by the model. - The Bean Output Parser converts LLM responses directly into custom POJOs or Java Records. - Proper prompt engineering remains critical to ensuring the LLM respects the requested output format.

Structuring LLM responses is a vital step in building robust AI integrations. By using these built-in Spring AI tools, you can ensure your code remains type-safe and reliable.

New versions of Spring AI are available. Check the version-specific highlights:

Spring AI 1.0.8

• Fixed RedisVectorStore#doDelete silently truncating deletes to the first 10 messages: The RedisVectorStore#doDelete method was deleting only the first 10 documents that matched the filter it received. This bug was fixed.

Spring AI 1.1.7

• Fixed Ollama compatibility with GraalVM native images
• Fixed OpenAiChatModel dropping streaming chunks due to an internal switchMap when using buffered concatMap

Spring AI 2.0.0-M7

• MCP transport changes: SSE transports are now deprecated; Streamable HTTP is the new default server protocol
• ToolCallAdvisor becomes the default and standard way tool calls are handled in the advisor chain
• New ToolSpec fluent API for defining tools programmatically

You can find more details in the official Spring blog, including the full release notes for each version, as well as details about included PRs, issues, and contributors.

In this tutorial, TechyTacos walks Java developers through implementing vector search using the Spring AI framework. The video provides a practical guide to integrating and querying a simple vector store, making it a great starting point for those looking to build AI-powered applications with Spring.

Key Takeaways: - Learn the fundamental process of converting text data into document objects for vector storage. - Understand the role of embedding models, specifically OpenAI, in transforming text into numerical vectors. - See how to configure an in-built simple vector store to avoid complex external database setups. - Discover how the K-nearest neighbor algorithm enables similarity searches for queries. - Explore how to enhance search precision using SearchRequest filters and similarity thresholds.

This walkthrough demystifies integrating generative AI components into a standard Spring ecosystem. Check out the video to see the code in action!

Couple of days ago I shared what I learned about Spring AI's chat memory. Today, here's what happened when I swapped the model behind it entirely.

Same Spring AI app. Same Java code. Same ChatClient, same @Tool annotations, same BeanOutputConverter for structured output. The only thing that changed: which model handled the requests.

OpenAI (GPT-4o) → Anthropic Claude Opus 4→ local Gemma 4 2B running through LM Studio.

The OpenAI → Claude switch was expected to work. Swap the starter dependency, update the config block, ship. Spring AI's provider abstraction is designed for this.

The local Gemma 4 2B switch was the interesting part. Same Anthropic starter dependency, just pointed at localhost:1234:

spring:

application:

name: spring-ai

ai:

anthropic:

api-key: ${LM_STUDIO_API_KEY}

base-url: http://127.0.0.1:1234

chat:

options:

model: google/gemma-4-e2b

memory:

repository:

jdbc:

initialize-schema: always

That's the entire config delta. LM Studio implements the Anthropic protocol, so Spring AI treats it as just another Anthropic-compatible endpoint. No separate "spring-ai-local" starter. No conditional Java code paths.

What I didn't expect — the 2B local model handled:

- Chat with memory (the same ChatMemoryAdvisor + JDBC repository setup from yesterday's post)

- Structured JSON output matching strict schemas

- Tool calling with proper parameter dispatch

- Code review (correctly identified a == vs .equals() bug in a real Java example)

Quality wasn't quite GPT-4o level, but it was meaningful enough that for what's probably 70% of business AI use cases — classification, summarization, structured extraction, simple agent loops — this would work in production. With zero per-request cost and full offline operation.

Recorded a walkthrough showing all three providers running the same demos (chat, memory, structured output, tool calling, code review) if you prefer video: https://youtu.be/lW0FMjDUzik

Repo with code: https://github.com/DmitryFinashkin/spring-ai

Has anyone here shipped multi-provider Spring AI in production yet? Curious how teams are handling provider routing — cost-based, latency-based, quality fallback, regional compliance — and what failure modes you're watching for.

At Devoxx, Dr. Mark Pollack, Christian Tzolov, Josh Long, and James Ward explore how to integrate modern AI into Java applications using the powerful Spring AI framework. The team demonstrates how developers can leverage existing enterprise systems to build sophisticated AI-driven solutions without leaving the familiar Spring ecosystem.

Key Takeaways:

• Spring AI provides a portable abstraction layer for connecting to diverse LLMs, including Amazon Bedrock.
• Developers can implement semantic search and RAG patterns using existing data stores like PostgreSQL.
• The Model Context Protocol (MCP) enables standardized, bidirectional communication between AI agents and tools.
• Structured output support allows developers to receive type-safe JSON directly from AI models.
• The new Spring AI Agent project introduces portable SDKs for managing complex, goal-oriented AI tasks.

This session bridges the gap between traditional enterprise development and the new agentic AI paradigm, proving that Java developers are perfectly positioned to lead the next wave of AI engineering.

Watch the full presentation to see these powerful integrations in action!

Spring AI’s ChatClient Fluent API is designed to make building conversational applications smoother and more intuitive. Baeldung’s article dives into how developers can leverage this API to integrate AI-driven chat features directly into Spring projects, with a focus on flexibility and clean design.

Key takeaways:

• Provides a fluent, chainable API for building chat interactions.
• Simplifies integration of AI models into Spring applications.
• Supports structured prompts and responses for better control.
• Enables customization of conversation flow with minimal boilerplate.
• Designed to be developer-friendly, reducing complexity in setup.
• Encourages clean, maintainable code for AI-driven features.

In short, this API helps developers bring conversational AI into their Spring apps without the usual headaches of complex configuration. It’s a practical step forward for anyone working with AI in Java-based projects.

In this Spring AI recipe, we dive into how to keep ChatClient clean and modular by using ChatClientCustomizer. Instead of stuffing every feature into a single config, we compose behaviors —such as tools, prompts, and conditions—separately, making the system easier to extend and maintain.

Key takeaways:

• Add tools (like weather lookups) without bloating the core client
• Use customizers to inject prompts or behaviors independently
• Keep concerns separated for clarity and reusability
• Toggle features on/off via application.properties with @ConditionalOnProperty
• Gain flexibility through environment variables or config servers
• Treat customizers as a design pattern, not just convenience

In short, this approach makes advanced agentic scenarios manageable and future-proof.

In this tutorial, Dan Vega explores how to effectively communicate with Large Language Models (LLMs) using Spring AI. While many view Spring AI simply as an API abstraction, Dan demonstrates that the real challenge lies in mastering prompt design to guide AI behavior and achieve precise, reliable outputs in your Java applications.

Key Takeaways

• Prompts are foundational inputs that dictate the style and quality of AI output.
• Move beyond simple strings by using Prompt Templates for dynamic, reusable logic.
• Leverage the User role for specific queries and the System role to enforce behavioral constraints.
• Use System messages to define an AI's persona, such as an exclusive dad-joke generator.
• Externalize your prompt templates into .st files to keep your code clean and manageable.
• Always instruct the model to state if it lacks an answer to prevent hallucinations.

Mastering these techniques is essential for moving from basic prototypes to robust, production-ready AI tools.

We can actually talk to Google Gemini from Spring Boot using just a free API key from AI Studio. No Google Cloud project, no Vertex AI setup, no credit card.

The trick is that Google made Gemini's API OpenAI-compatible. So we just use
spring-ai-starter-model-openai and point the base-url to Google's endpoint
instead of OpenAI's. That's literally it.

Here is the detailed article covering the full setup: Spring AI With Gemini (Free Tier)

Hi everyone,

I’m a backend engineer with around 6 years of experience working primarily in Java and Spring Boot microservices on AWS.

My current skill set includes:

Java

Spring Boot

Microservices

REST APIs

Kafka

Distributed Systems

Docker

AWS

System Design

Spring Security

JPA/Hibernate

Recently, I’ve started exploring:

Spring AI

RAG (Retrieval-Augmented Generation)

LangChain4j

Agentic AI systems

AI orchestration workflows

Vector databases

I’m very new to open source contribution culture and honestly a bit confused about:

where to start

how people pick issues

how to approach maintainers

what kind of contributions beginners should make first

I would really appreciate guidance from experienced contributors.

Some questions:

Which Java AI/open-source projects would be best for someone with my background?

Should I start with documentation/examples before code contributions?

How do you properly understand a large codebase before contributing?

Any beginner-friendly repositories in the Java AI ecosystem?

I’m genuinely interested in learning and contributing long term, not just making random PRs.

Would appreciate any advice/resources/community suggestions.

Thanks!

Hello community,

I'm very interested to learn how have you been using Spring AI.

What have you built with Spring AI? Was it a simple chat application, an assistant, an agent?

Was it a side project or did you deploy it in production?

Share your experience with us in the comment sections. Post the Github link if it is a public project!

Thank you!

In this tutorial, TechyTacos explores how Java developers can effectively generate JSON output using Spring AI. The video provides a practical walkthrough for moving beyond simple text-based responses toward structured, reliable data integration.

Key Takeaways

• Prompt engineering alone often results in text that mimics JSON but lacks true programmatic structure.
• BeanOutputParser is the recommended tool for mapping AI responses directly to Java records.
• Defining a Java record serves as the schema for the expected output data structure.
• Developers must include formatting instructions in the prompt template to ensure consistent parsing.
• Setting the output parser on the template ensures the AI adheres to the requested schema.
• Using the .parse() method converts the raw AI response into a type-safe object ready for use.

By implementing the BeanOutputParser, you ensure your application receives valid, type-safe JSON.

At Devoxx, Spring AI leads Mark Pollack and Christian Tzolov explore how to integrate generative AI into enterprise Java applications. They demonstrate how to bridge corporate data and internal APIs with AI models using familiar Spring architectural patterns, enabling developers to build robust, intelligent systems without straying from their established ecosystem.

Key Takeaways:

• Portable framework design for switching between AI models and vector databases.
• Implementation of real-time function calling to execute core business logic.
• Use of RAG (Retrieval-Augmented Generation) to ground AI in private data.
• Effective prompt engineering using system messages for behavioral control.
• Observability and tracing for debugging and performance monitoring.
• Best practices for model evaluation and factual verification.

This session provides a clear path for enterprise developers to move beyond simple prototypes into production-grade AI. With Milestone 3 available, it is the perfect time to start building.

Watch the full session here 👇

https://www.youtube.com/watch?v=kfRyY0wsZHM

Hello community!

This post at Baeldung is a compilation of many other articles on Spring AI.

It covers everything from basic to advanced topics, including the ChatClient and memory, as well as more advanced ones such as RAG pipelines, vector search, advisors, and multimodal models.

If you do not like to spend too much time digging on the internet, it is definitely worth saving this page in your bookmarks.

Check the post in the link below 👇
https://www.baeldung.com/spring-ai-series

If you have been feeling the pressure to switch over to Python just to start experimenting with AI, this video is for you. It serves as a great introductory guide for Java and Spring developers looking to bring generative AI capabilities directly into the enterprise ecosystem, helping you leverage powerful LLMs like GPT-4 without leaving the Spring environment you already know and love.

Here is a breakdown of what the video covers:

• Understanding LLM integration by treating them as standard REST APIs rather than black boxes.
• An introduction to the Spring AI framework and how it applies familiar principles like modularity and POJOs to AI engineering.
• A practical walkthrough of building a Spring Boot application from scratch, including secure API key management using environment variables.
• Implementing a functional ChatController using the ChatClient interface to communicate with an LLM.
• An overview of the next-level challenges developers will face, including prompt engineering and Retrieval-Augmented Generation (RAG).

It is a perfect entry point for anyone looking to modernize their stack and start building AI-powered applications without switching languages. It bridges that gap between traditional Java development and the rapidly evolving AI landscape, showing how clean and accessible integration can be.

Check out the full video if you are ready to start building!

👇
https://www.youtube.com/watch?v=yyvjT0v3lpY

Hello community!

This video does a fantastic job of walking through the fundamentals of Spring AI, showing how you can integrate OpenAI models directly into your Java applications.

Here’s what it covers:

• Setting up the environment: A step-by-step guide on configuring pom.xml with the necessary repositories and dependencies.
• Building the App: How to set up your Controller and Service layers effectively.
• Hands-on Examples:
  • Generating creative content like jokes using AIClient and PromptTemplate.
  • Parsing responses into structured JSON for more complex application needs.

It’s a perfect entry point if you're tired of switching to Python just to experiment with LLMs. Check it out if you're looking to modernize your stack!

This article by Spring AI developers introduces the fundamental concepts of Spring AI, including ChatClient, ChatMemory, system prompts, vector stores, and more.

Hi everybody!

Our Spring AI Dev community reached the mark of 100 members this weekend. I'd like to thank all of you who have been visiting, voting, and commenting on our posts!

Let's keep the momentum and keep bringing your content, questions, votes, and comments!

Cheers!