The repositories that go beyond hello-world and show you RAG, MCP, agents, and production patterns — with real Java code.
I spent three weeks trying to learn Spring AI through blog posts.
Every single one of them did the same thing: add the OpenAI starter dependency, inject a ChatClient, call .call().content(), print "Hello from GPT." Congratulations, you've built nothing.
Spring AI 1.0 reached general availability in May 2025. Since then, it has quietly become one of the most practical frameworks for Java developers who want to build real AI-powered applications — RAG pipelines, tool-calling agents, MCP integrations, vector store workflows. Not demos. Actual production systems.
But the learning curve has a brutal gap: official docs get you to “hello world” in twenty minutes and then leave you completely alone when you try to build something that actually works.
The fix isn’t another tutorial. It’s going directly to the source — open-source repositories written by people who’ve already solved the problems you’re about to hit.
Here are five repositories worth your time. One of them will almost certainly restructure how you think about AI in Java.
Java developers have been late to every major AI wave. Python owns the ML research world. JavaScript grabbed the ChatGPT wrapper market. And for a while, it looked like Java would sit this one out too.
That changed when Spring AI shipped its 1.0 GA release with something the Python frameworks don’t have: an opinionated, enterprise-ready abstraction layer that works the way Spring developers already think.
Spring AI doesn’t feel like a bolted-on AI library. It feels like Spring Data for LLMs.
The ChatClient follows the same fluent builder pattern as WebClient. Auto-configuration works the same way it does for databases. The VectorStore abstraction behaves like JdbcTemplate. If you've spent years in the Spring ecosystem, the mental model transfers almost directly.
The problem is that most learning resources treat Spring AI like a toy. The repositories below don’t.
GitHub: github.com/spring-projects/spring-ai This is the official Spring AI repository maintained by VMware and the Spring team. Most developers add it as a dependency and never open it. That’s a mistake.
The source code is genuinely readable. The abstractions — ChatClient, EmbeddingModel, VectorStore, ToolCallback, Advisor — are clean enough that reading the interfaces teaches you more about how to use the framework than most tutorials will. The repository also contains integration tests that show exactly how each provider (OpenAI, Anthropic, Ollama, Mistral, Google Gemini) is expected to behave.
The framework ships with first-class support for:
Clone the repo, open spring-ai-core/src/main/java/org/springframework/ai/chat/client/ChatClient.java. Read the interface. Then open any of the integration tests under /spring-ai-integration-tests. You'll understand the contract faster than any article can explain it.
The codebase moves fast. If you’re reading this in late 2026, some APIs may have shifted from when the 1.0 GA dropped. Always check the changelog before assuming a tutorial’s code still compiles.
Don’t just add Spring AI as a black box. Spend one hour reading the core interfaces. It’s the fastest path to writing idiomatic Spring AI code instead of cargo-culted snippets.
GitHub: github.com/spring-projects/spring-ai-examples The official examples repository maintained alongside the framework. This is where the Spring team demonstrates how they intend the framework to be used — not how influencers simplify it for YouTube.
The examples here cover patterns that take real effort to discover elsewhere:
This isn’t a tutorial repository. It’s a reference implementation. The difference matters: tutorials explain; reference implementations demonstrate what production code is supposed to look like.
The MCP examples folder shows how to build a Spring Boot application that both consumes MCP servers and exposes its own services to the AI ecosystem. This pattern is increasingly relevant as MCP becomes the standard for tool interoperability between AI systems.
Examples are sometimes added faster than they’re updated. A pattern that was experimental in one release may have a cleaner API in the next. Cross-reference with the official changelog.
Before writing any new Spring AI feature, search this repository first. Someone on the Spring team has almost certainly already shown the idiomatic approach.
GitHub: github.com/spring-ai-community/awesome-spring-ai A curated aggregation of tutorials, videos, projects, conference talks, and blog posts around Spring AI, maintained by the community organization. It currently sits at ~790 stars, which dramatically undersells how useful it is.
This is the one most Java developers skip. That’s the mistake.
Learning Spring AI in isolation is slow. The Spring AI ecosystem includes integrations with dozens of vector databases, model providers, memory backends, and agent frameworks. awesome-spring-ai maps the entire landscape and saves you hours of searching for the right resource.
The repository includes:
One example from the repository’s showcase section: a modular demo by Piotr Minkowski that demonstrates RAG with Pinecone, multi-provider support (OpenAI, Mistral, Ollama, Azure OpenAI), and structured output — all in a single project. That kind of end-to-end reference is exactly what you can’t find in a Medium post.
Curation quality varies across sections. The video and conference talk links tend to be more reliably current than some of the blog post links. Always check the publish date before following a tutorial from here, especially for API-specific content.
Bookmark this repository on day one. Return to it every time you hit a new concept in Spring AI. The chances are high that someone has already explained it, built it, or talked about it at a conference.
GitHub: github.com/habuma/spring-ai-examples A community examples repository by Craig Walls, author of Spring in Action and now Spring AI in Action (Manning). This is code written by someone who has spent years figuring out how to explain Spring clearly.
The difference between this repository and generic Spring AI tutorials is pedagogical intent. The examples are structured to be progressively learned — you can clone the entire project or use Spring CLI to extract individual examples. Each demonstrates a specific, isolated concept without burying you in surrounding complexity.
The examples cover:
The function calling examples are particularly well-structured. Function calling (now also called “tool calling” in Spring AI 1.0) is one of the hardest concepts to understand from documentation alone. The repository shows the pattern clearly: define a @Bean, describe it for the model, handle the invocation — without the noise that most tutorials add around it.
This repository is tied to a book. Some examples exist primarily to illustrate book chapters. That’s not a criticism — the book is well-regarded — but it means the coverage follows a book’s arc rather than a “most commonly needed patterns first” ordering.
Use this alongside the book if you can. Even without it, the examples stand on their own. Start with the function calling and structured output sections if you’re past the basics.
**GitHub:** github.com/spring-ai-community/spring-ai-agent-utils
A Spring AI library that brings Claude Code-inspired tools and agent skills to Spring AI applications. This is newer territory — agent patterns in Spring AI are still maturing — but this repository represents one of the most concrete implementations of multi-agent coordination in the Java ecosystem.
Most “AI agent” tutorials in Java land show you how to call a model twice and call it an agent. This repository goes further: it demonstrates sub-agent coordination, skill-based architecture (where agents are given modular capabilities), task delegation, and integration with real tools like web search.
The architecture reflects Anthropic’s published patterns for building effective agents — which means the design decisions here are grounded in how production agent systems are actually structured, not how they’re dramatized in demos.
This is also where you’ll see how MCP and agent patterns combine in practice. The MCP transport support (STDIO, SSE, Streamable HTTP) in Spring AI 1.0 makes it possible to build agents that interoperate with external AI systems — and this repository shows what that wiring looks like.
The TaskTool implementation allows a primary agent to delegate work to sub-agents with defined skill sets. The configuration uses Spring Boot idioms — @Bean, CommandLineRunner, environment properties — which means the pattern fits into existing Spring applications without architectural surgery.
Agent patterns are moving fast across the entire AI industry. What’s experimental today may be standard in six months or deprecated in twelve. Treat this repository as a reference for current best practices, not a stable API contract.
Agentic systems don’t fail because the model makes mistakes. They fail because the plumbing around the model was never designed for real workloads.
If you’re building anything beyond simple chat interfaces — pipelines, automated workflows, multi-step reasoning systems — study the agent patterns here before writing your own. The architecture decisions are non-trivial and getting them wrong costs weeks. Starting with the wrong mental model. Spring AI is not LangChain with a Java syntax. The Advisor API, the ChatClient fluent interface, and the auto-configuration model are Spring idioms. If you try to translate Python patterns directly, you'll write code that works but reads like it doesn't belong.
**Ignoring the **Advisor API for RAG. Most RAG tutorials manually handle retrieval and prompt augmentation. Spring AI's QuestionAnswerAdvisor and the experimental RetrievalAugmentationAdvisor encapsulate this logic cleanly. Skipping them means more boilerplate and less flexibility later.
Using deprecated patterns from pre-1.0 examples. Spring AI changed significantly before its 1.0 GA release. A lot of tutorials online still use the pre-GA API. Always check whether a tutorial was written after May 2025 before copying its patterns.
Underestimating vector store setup. Each VectorStore implementation (pgvector, Pinecone, Redis, Weaviate, and others) has its own initialization requirements. Some need schema setup that isn't automatic. Check the provider-specific documentation before assuming autoconfiguration handles everything.
Building agents before understanding tools. Tool calling is the foundation of any meaningful agentic pattern. If you can’t cleanly define, describe, and handle a single tool call, you’re not ready to coordinate multiple agents.
The Advisor pattern in Spring AI is more powerful than it appears at first glance. Advisors intercept and transform data exchanges between your application and the model — which means they're not just for RAG. You can use them for logging, output validation, retry logic, and context injection. Most developers use one advisor (for RAG) and stop there. The composability goes much further.
The MCP support is also more mature than I expected for a 1.0 release. Spring AI ships MCP Boot Starters that make building both MCP servers and clients a configuration exercise rather than an implementation exercise. As MCP adoption grows across AI tooling, this becomes a genuine competitive advantage for the Spring ecosystem.
Spring AI doesn’t remove the complexity of building AI systems. It relocates it to the right layer — configuration and composition instead of boilerplate wiring.
The Spring AI roadmap points toward tighter integration with the broader Spring ecosystem: Spring Data for vector operations, Spring Security for MCP authorization, Spring Observability for production monitoring of LLM calls.
MCP is becoming the interoperability standard that HTTP was for APIs. Spring AI’s first-class MCP support positions Java backends to become first-class participants in AI tool ecosystems — not just consumers of them.
The agentic patterns are the most uncertain piece. The community is still figuring out what production agent architectures look like at scale. The spring-ai-community organization is where most of this experimentation is happening publicly. Watching those repositories is the fastest way to stay current.
What’s clear is that enterprise AI workloads are Java workloads. Observability, security, connection pooling, configuration management, deployment pipelines — these are solved problems in the Spring ecosystem. Spring AI is the bridge that brings LLMs into an environment where those problems stay solved.
You don’t need another hello-world tutorial. You need to read code written by people who’ve solved real problems with Spring AI — and then build something that breaks, figure out why, and build it again.
The five repositories above give you that foundation:
The most important thing you can do is clone them, run them, and then break them deliberately. Edit the prompts. Swap the model provider. Add a vector store. Remove the advisor and see what changes. That’s where the real learning happens.
Every AI abstraction eventually leaks. The best frameworks leak in predictable places. Spring AI, so far, leaks where Spring always has — which means you already know how to debug it.
If you enjoy practical AI workflows, open-source software insights, developer productivity strategies, startup trends, and future-of-work analysis, consider following for more in-depth articles.
What has been the biggest change in your workflow over the last year?
5 Open-Source GitHub Repos That Actually Teach You Spring AI (Most Java Devs Skip) was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.