Einführung

Spring AI hat sich bis Herbst 2025 zu einem umfassenden Application Framework für AI Engineering entwickelt. Es bringt die bewährten Designprinzipien des Spring-Ökosystems wie Portabilität und modulares Design in den Bereich der Künstlichen Intelligenz. Ein besonders interessantes Feature ist die Unterstützung des Model Context Protocols (MCP), das eine standardisierte Schnittstelle für die Kommunikation zwischen Anwendungen und KI-Modellen definiert.

Was ist Spring AI?

Spring AI ist ein Framework, das das Ziel hat, Enterprise-Daten und APIs mit AI-Modellen zu verbinden. Es bietet:

  • Unterstützung für alle wichtigen AI-Model Provider (Anthropic, OpenAI, Microsoft, Amazon, Google, Ollama)
  • Portable APIs über verschiedene AI-Provider hinweg
  • Unterstützung für Vector Databases
  • Tools/Function Calling für Client-seitige Ausführung
  • ChatClient API mit streaming Unterstützung
  • RAG (Retrieval Augmented Generation) Unterstützung
  • Auto-Configuration für Spring Boot

Was ist ein MCP Server?

Das Model Context Protocol (MCP) definiert eine standardisierte Schnittstelle für die Kommunikation zwischen Anwendungen und KI-Modellen. Ein MCP Server stellt Tools und Ressourcen zur Verfügung, die von KI-Modellen genutzt werden können.

MCP Server ermöglichen es:

  • Bestehende Anwendungen KI-fähig zu machen
  • Tool-ausführungen zu standardisieren
  • Kontextuelle Informationen bereitzustellen
  • Nahtlose Integration in AI-Workflows

MCP Server mit Spring Boot erstellen

1. Projekt einrichten

Erstelle ein neues Spring Boot-Projekt mit den folgenden Abhängigkeiten:

  • spring-ai-mcp-server-spring-boot-starter
  • spring-web

Du kannst das Projekt mit dem Spring Initializr erstellen und die gewünschten AI-Modelle und Vector Stores auswählen.

2. Anwendungsklasse

@SpringBootApplication
public class McpServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(McpServerApplication.class, args);
    }
}

3. Wetter-Service implementieren

Implementiere einen Service, der Wetterdaten bereitstellt. Verwende die @McpTool-Annotation, um Methoden als MCP-Tools zu kennzeichnen:

@Service
public class WeatherService {

    public record WeatherResponse(Current current) {
        public record Current(LocalDateTime time, int interval, 
                              double temperature_2m) {}
    }

    @McpTool(description = "Get the temperature (in Celsius) for a specific location")
    public WeatherResponse getTemperature(
        @McpToolParam(description = "The location latitude") double latitude,
        @McpToolParam(description = "The location longitude") double longitude) {

        return RestClient.create()
            .get()
            .uri("https://api.open-meteo.com/v1/forecast?latitude={latitude}&longitude={longitude}&current=temperature_2m",
                latitude, longitude)
            .retrieve()
            .body(WeatherResponse.class);
    }
}

Diese Methode ruft die aktuelle Temperatur für gegebene Koordinaten ab und stellt sie als MCP-Tool zur Verfügung.

4. Anwendung konfigurieren

Füge folgende Konfiguration in application.properties hinzu:

spring.ai.mcp.server.protocol=STREAMABLE

Diese Konfiguration startet den MCP-Server mit dem Streamable-HTTP-Transport. Das Streamable-Protokoll ermöglicht effiziente bidirektionale Kommunikation.

5. Anwendung starten und testen

Baue und starte die Anwendung:

./mvnw clean install -DskipTests
java -jar target/mcp-weather-server-0.0.1-SNAPSHOT.jar

Der MCP-Server läuft nun auf Port 8080 und kann mit MCP-kompatiblen Clients interagieren. Du kannst beispielsweise den MCP Inspector verwenden, um den Server zu testen.

Erweiterte MCP-Tools

Spring AI unterstützt auch komplexere MCP-Tools mit verschiedenen Parametertypen:

@Service
public class DocumentService {

    @McpTool(description = "Search documents by keyword")
    public List<Document> searchDocuments(
        @McpToolParam(description = "Search keyword") String keyword,
        @McpToolParam(description = "Maximum results") int limit) {
        
        return documentRepository
            .findByKeywordContaining(keyword)
            .stream()
            .limit(limit)
            .toList();
    }

    @McpTool(description = "Get document content")
    public String getDocumentContent(
        @McpToolParam(description = "Document ID") String documentId) {
        
        return documentRepository
            .findById(documentId)
            .map(Document::getContent)
            .orElseThrow();
    }
}

Spring AI Features

ChatClient API

Spring AI bietet eine idiomatische ChatClient API, die ähnlich wie WebClient und RestClient funktioniert:

@Autowired
private ChatClient.Builder chatClientBuilder;

public String chat(String message) {
    return chatClientBuilder
        .build()
        .prompt(message)
        .call()
        .content();
}

Structured Outputs

AI-Modell-Ausgaben können direkt auf POJOs gemappt werden:

public class UserProfile {
    private String name;
    private int age;
    private String email;
}

UserProfile profile = chatClient
    .prompt("Extract user info from: " + text)
    .call()
    .entity(UserProfile.class);

Vector Stores Integration

Spring AI unterstützt alle wichtigen Vector Database Provider:

@Autowired
private VectorStore vectorStore;

public void storeDocument(String content) {
    vectorStore.add(List.of(
        new Document(content, 
            Map.of("source", "web", "timestamp", Instant.now()))
    ));
}

Konfiguration für verschiedene AI-Provider

OpenAI

spring.ai.openai.api-key=YOUR_API_KEY
spring.ai.openai.chat.options.model=gpt-4

Anthropic Claude

spring.ai.anthropic.api-key=YOUR_API_KEY
spring.ai.anthropic.chat.options.model=claude-3-opus-20240229

Ollama (lokal)

spring.ai.ollama.base-url=http://localhost:11434
spring.ai.ollama.chat.options.model=llama2

Fazit

Spring AI bietet eine leistungsstarke und flexible Lösung für die Integration von AI-Funktionen in Java-Anwendungen. Mit der MCP-Unterstützung können Entwickler maßgeschneiderte AI-Services erstellen und die Kommunikation zwischen Anwendungen und KI-Modellen standardisieren.

Die modulare Architektur und die portable API ermöglichen es, zwischen verschiedenen AI-Providern zu wechseln, ohne den Application-Code ändern zu müssen. Das macht Spring AI zu einer idealen Wahl für Enterprise-Anwendungen, die KI-Funktionen benötigen.

Durch die nahtlose Integration in das Spring-Ökosystem profitieren Entwickler von bewährten Patterns wie Dependency Injection, Auto-Configuration und den vielen vorhandenen Spring-Boot-Features.

Weitere Ressourcen