Spring AI: универсальный адаптер между Java и LLM — возможности, настройка и интеграция

Допустим, вы Java-разработчик. Вокруг гудят нейросети, все пишут промпты на Python, а вы сидите со своим любимым Spring Boot и чувствуете себя как пассажир электрички, которая проезжает мимо станции «Искусственный интеллект». Знакомо?

Раньше интеграция любой языковой модели в Java-проект выглядела как извращение: парсить JSON, стучаться к REST API, писать свой пул соединений, разбираться с токенами. Потом появлялись разные костыли — то библиотека от OpenAI на Java, то самописная обёртка. Всё это работало, но каждый раз приходилось изобретать велосипед с квадратными колёсами.

И тут на сцену выходит Spring AI. Не путайте с AI Spring (такой игрушки нет). Это официальный проект от VMware — модуль, который превращает работу с большими языковыми моделями в привычный Spring-стиль. Бобы, инжекция, аннотации — всё как мы любим.

Я покопался в этом звере, поднял локальную Ollama с Llama 3, подцепил облачный OpenAI, покрутил function calling и даже попробовал RAG. Спойлер: работает. Но есть нюансы. О них и поговорим.

Что это вообще такое и зачем мне это?

Spring AI — это набор стартеров и утилит, который даёт единый API для общения с разными LLM. Хотите OpenAI — пожалуйста. Хотите Anthropic Claude — нет проблем. Решили запустить модель локально через Ollama — Spring AI подхватит. Даже Amazon Bedrock, Google Vertex AI, Azure OpenAI — все под одним зонтиком.

Но главная фишка не в количестве провайдеров. Главное — это то, как Spring AI вписывается в экосистему Spring. Вы просто добавляете зависимость, прописываете пару строк в application.yml — и получаете бин ChatClient, готовый к работе. Никаких ручных HTTP-запросов, никакого адаптивного парсинга ошибок. Spring сделает это за вас.

Более того, Spring AI умеет не только болтать. Он поддерживает:

• Embeddings — превращение текста в вектора для поиска по смыслу (RAG).
• Function calling — модель сама решает, когда вызвать вашу Java-функцию. Вжух — и ИИ уже загружает данные из БД.
• Chat memory — хранит историю диалога, чтобы модель не забывала, о чём вы говорили три сообщения назад.
• ETL pipeline — загрузка документов (PDF, JSON, TXT), их нарезка и векторизация. Всё встроено.
• Tool Calling — модель может вызывать внешние инструменты, аналог MCP. Кстати, о MCP: если вы следите за темой, почитайте как IDE сама начинает думать за вас с Explyt Spring MCP — это другой, но смежный подход.

Звучит как серебряная пуля? Не совсем. Но давайте разберёмся по косточкам.

Как это выглядит в коде (и почему это удобно)

Типичный сценарий: вы хотите дать пользователю возможность спросить у AI про погоду. Без function calling вам пришлось бы парсить намерения вручную. С Spring AI — модель сама решает, что нужно вызвать метод getWeather.

Подключаем стартер:

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>1.0.0-M6</version>
</dependency>

Прописываем в application.yml ключи (для локальной Ollama — без ключа, только URL):

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        model: gpt-4o-mini

И используем:

@Service
public class WeatherService {

    private final ChatClient chatClient;

    public WeatherService(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    public String askAboutWeather(String userMessage) {
        return chatClient.prompt()
            .user(userMessage)
            .call()
            .content();
    }
}

Всё. Никакого RestTemplate, никакой ручной сериализации. Если вы когда-нибудь писали JdbcTemplate или RestTemplate, то ChatClient покажется родным.

А для function calling нужно просто описать Java-метод аннотацией @Tool:

@Component
public class WeatherTools {

    @Tool(name = "get_current_weather", description = "Получить температуру в городе")
    public String getWeather(String city) {
        // тут вы стучитесь к погодному API
        return "В городе " + city + " сейчас +15°C";
    }
}

И включить авто-регистрацию инструментов. Spring AI сам передаст описание функции модели, а когда модель решит её вызвать — выполнит метод и вернёт результат обратно. Гениально и просто.

Spring AI против других: кого бить?

На рынке Java-решений для AI не так много игроков. Главный конкурент — LangChain4j. Он тоже популярен, тоже поддерживает кучу моделей, но устроен иначе.

Если вы уже влюблены в Spring Boot — Spring AI ваш выбор. LangChain4j больше подходит, когда вам нужна максимальная гибкость и вы готовы пожертвовать магией «всё под капотом». Я бы сказал так: Spring AI — это как Spring Data JPA для AI, а LangChain4j — как jOOQ. Одно удобно и быстро, другое даёт полный контроль.

Есть ещё куча самодельных решений и клиентов для отдельных моделей. Но они живут своей жизнью и не поддерживают function calling так, как это делают два гиганта. Если вам нужно быстро прототипировать AI-фичи — берите Spring AI.

Локальный запуск: Ollama + Spring AI = безоблачное счастье

Облачные LLM дороги (платишь за токены) и не всегда доступны по закону. Локальный запуск LLM — тренд 2025-2026. Spring AI из коробки поддерживает Ollama, LM Studio, llama.cpp. Просто переключаете провайдера в настройках.

Вот так выглядит конфиг для локальной модели:

spring:
  ai:
    ollama:
      base-url: http://localhost:11434
      chat:
        model: llama3.2:3b

И код остаётся тем же. ChatClient не знает, откуда приходит ответ — из облака или с вашей видеокарты. Это прекрасно.

Для сравнения инструментов локального запуска — взгляните на LM Studio vs llama.cpp — там найдёте, что лучше подходит под ваше железо. Spring AI поддерживает оба через Ollama, так что можете комбинировать.

Кстати, если вы думаете, что локальные модели слабее — не спешите. Llama 3.2 70B на мощном сервере даёт фору многим старым облачным моделям. А для простых задач вроде суммаризации или ответов по документам достаточно 7-8B.

Реальный пример: AI-агент, который сам ищет информацию

Попробуем собрать простого AI-агента, который может отвечать на вопросы по технической документации. Spring AI позволяет создать цепочку (chain): сначала векторизовать документы, потом по запросу искать релевантные куски, и только потом передавать их в промпт вместе с вопросом.

Код скелета RAG на Spring AI:

@Bean
public VectorStore vectorStore(EmbeddingModel embeddingModel) {
    return new SimpleVectorStore(embeddingModel);
}

@Service
public class RAGService {

    private final ChatClient chatClient;
    private final VectorStore vectorStore;

    public RAGService(ChatClient.Builder builder, VectorStore vectorStore) {
        this.chatClient = builder
            .defaultSystem("Вы — эксперт по Java. Отвечайте только на основе предоставленного контекста.")
            .build();
        this.vectorStore = vectorStore;
    }

    public String answer(String question) {
        List<Document> similarDocs = vectorStore.similaritySearch(question);
        String context = similarDocs.stream()
            .map(Document::getContent)
            .collect(Collectors.joining("\n"));

        return chatClient.prompt()
            .user(u -> u.text("Вопрос: {question}\nКонтекст: {context}")
                .param("question", question)
                .param("context", context))
            .call()
            .content();
    }
}

В реальном проекте вы бы ещё добавили обрезку контекста по токенам, кеширование, асинхронность. Но основа готова за 20 минут. Никакого Python, никаких серверов.

Кстати, про AI-агентов: если хотите пощупать более сложные сценарии с суб-агентами, советую гайд по правильному использованию суб-агентов — там показаны паттерны, которые легко реализовать на Spring AI через цепочки вызовов.

Что под капотом и где подвох

Spring AI — это не только ChatClient. Архитектура построена на концепции провайдеров (модули для каждого API) и адаптеров. Вы можете дописать свой адаптер, если хотите использовать модель, которой нет в списке. В обзоре open-source инструментов для LLM можно найти альтернативные библиотеки, но Spring AI — самый «причёсанный» вариант для Spring.

Но есть ложка дёгтя. Во-первых, документация ещё «молодая» — некоторые сценарии описаны поверхностно, приходится лезть в исходники. Во-вторых, не все провайдеры одинаково хорошо поддерживают function calling. Например, для Ollama надо ставить последнюю версию мод. В-третьих, Spring AI пока не умеет автоматически управлять контекстом (вроде truncation по токенам) — приходится делать это вручную.

Тем не менее, проект активно развивается. Версия 1.0.0-M6 уже стабильна для большинства задач, а к релизу 1.0.0 обещают полную документацию и поддержку streaming в function calling.

Кому это реально нужно?

Короткий ответ: Java-разработчикам, которые хотят добавить AI в приложение без смены стека. Если у вас монолит на Spring Boot, поднять чат-бота с RAG — дело нескольких часов. Если вы пишете микросервисы — Spring AI легко встраивается в архитектуру (конечно, с осторожностью, чтобы не превратить всё в «магическую нейросеть-слой»).

Особенно полезно для:

• Enterprise-приложений, где нельзя уйти в Python и нужно соблюдать стандарты безопасности.
• Автоматизации поддержки — AI отвечает на тикеты, вызывая функции для поиска в базе.
• Интеграции с документацией — RAG позволяет модели отвечать только по вашим гайдам.
• Создания AI-ассистентов — в духе Meeting-LLM, но на Java. Кстати, для тех, кто хочет готового решения — гляньте на создание локального AI-ассистента для совещаний.

Если вы пишете на Kotlin Multiplatform или хотите AI-агентов на Android — советую посмотреть практическое руководство по AI-агентам на Kotlin Multiplatform — там используются другие подходы, но идеи универсальны.

Коротко о главном: брать или не брать?

Spring AI определённо стоит внимания. Это не просто обёртка над API — это архитектурный паттерн для работы с LLM в мире Java. Если у вас есть опыт Spring и вы не хотите учить Python ради «поиграться с AI» — это ваш инструмент.

Но не надейтесь, что достаточно добавить стартер и всё заработает само. Придётся разобраться с промпт-инжинирингом, с тем, как работают embeddings, и с тем, что локальные модели глючат на сложных запросах. Зато когда вы соберёте своего первого AI-агента на чистой Java — чувство удовлетворения перекроет все трудности.

Мой прогноз: в 2026-2027 Spring AI станет стандартом де-факто для AI-фич в Java-проектах, так же как Spring Boot для микросервисов. Начните копать уже сейчас, и через год будете гуру.

Подписаться на канал