Ir al contenido principal

Spring AI: First application

¡Hola! 👋 Si estás aquí, seguramente te pica la curiosidad sobre cómo integrar Inteligencia Artificial en tus aplicaciones Java sin complicarte la vida. Spring AI ha llegado para facilitarnos enormemente esta tarea, ofreciendo una abstracción unificada para interactuar con modelos como OpenAI, Azure, o incluso modelos locales con Ollama.

En este tutorial, vamos a crear juntos un ejemplo muy sencillo: un endpoint REST que te permitirá charlar con una IA. ¡Verás que con muy pocas líneas de código tienes algo funcionando!


¿Qué necesitamos antes de empezar?

Para seguir este tutorial sin problemas, asegúrate de tener a mano:

  • Java 17 o superior (Spring Boot 3 lo requiere).
  • Tu IDE favorito (IntelliJ, Eclipse, VS Code...).
  • Una API Key de OpenAI (puedes conseguirla en platform.openai.com). Si prefieres no gastar créditos, al final te cuento cómo hacerlo gratis con Ollama.

1. Creando los cimientos del proyecto

Lo más rápido es ir a start.spring.io y generar un nuevo proyecto. Selecciona:

  • Project: Maven
  • Language: Java
  • Spring Boot: 3.2.x o superior
  • Dependencies: Busca y añade:
    • Spring Web (para hacer nuestra API).
    • OpenAI (dentro de la sección "AI").

¿Prefieres configurar el pom.xml a mano?

Si ya tienes un proyecto y quieres añadirle "superpoderes", asegúrate de incluir el BOM (Bill of Materials) de Spring AI y el starter correspondiente. Tu pom.xml debería lucir algo así:

<properties>
    <java.version>17</java.version>
    <spring-ai.version>1.0.0-SNAPSHOT</spring-ai.version> <!-- ¡Ojo! Revisa la última versión -->
</properties>

<dependencies>
    <!-- Necesario para crear nuestro endpoint REST -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- La magia de Spring AI para OpenAI -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-bom</artifactId>
            <version>${spring-ai.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- Importante: Spring AI aún puede estar en repositorios milestone -->
<repositories>
    <repository>
        <id>spring-milestones</id>
        <name>Spring Milestones</name>
        <url>https://repo.spring.io/milestone</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
</repositories>

2. Configurando la "Llave Maestra"

Ahora necesitamos decirle a nuestra aplicación cómo autenticarse con OpenAI. Abre tu archivo application.properties (o application.yml) y añade lo siguiente:

spring.application.name=spring-ai-demo

# Aquí va tu API Key. ¡No la compartas con nadie!
spring.ai.openai.api-key=${OPENAI_API_KEY}
spring.ai.openai.chat.options.model=gpt-3.5-turbo

Consejo Pro: En lugar de pegar tu API Key directamente en el archivo (y subirla por error a GitHub 😱), defínela como una variable de entorno en tu sistema: export OPENAI_API_KEY=tu-clave-secreta. Spring la recogerá automáticamente.


3. ¡A programar! 

Aquí viene la mejor parte. Gracias a Spring AI, interactuar con el modelo es trivial. Vamos a usar ChatClient, una interfaz fluida que simplifica mucho las llamadas.

Crea una clase llamada AIController.java:

package com.ejemplo.springai;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AIController {

    private final ChatClient chatClient;

    // Spring Boot es tan listo que nos inyecta el ChatClient ya configurado
    public AIController(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    @GetMapping("/chat")
    public String chat(@RequestParam(value = "message", defaultValue = "Cuéntame un dato curioso sobre programación") String message) {
        
        // ¡Mira qué sencillo! Le enviamos el mensaje al usuario y pedimos el contenido
        return chatClient.prompt()
                .user(message)
                .call()
                .content();
    }
}

¿Has visto? Solo 5 líneas de código real para tener un chatbot funcional.


4. El momento de la verdad 

Vamos a ver si esto funciona.

  1. Inicia tu aplicación Spring Boot:

    ./mvnw spring-boot:run
    
  2. Abre tu navegador o una terminal y prueba tu nuevo endpoint:

    curl "http://localhost:8080/chat?message=Explica+Spring+AI+como+a+un+niño+de+5+años"
    

¿Qué debería pasar?

Si todo ha ido bien, recibirás una respuesta generada por la IA, algo como:

"Imagina que Spring AI es como un traductor mágico. Tú le hablas en el idioma de Java (que es el que usas para construir tus juguetes de software) y él se encarga de hablar con los robots súper listos (las IAs) para que hagan lo que tú quieras, ¡sin que tengas que aprender a hablar robot!"


Bonus Track: ¿Y si quiero usar modelos locales (gratis)? 

Si no quieres depender de OpenAI o quieres privacidad total, puedes usar Ollama.

  1. Descarga e instala Ollama.
  2. En tu pom.xml, cambia spring-ai-openai-... por spring-ai-ollama-spring-boot-starter.
  3. En application.properties, apunta a tu local:
    spring.ai.ollama.base-url=http://localhost:11434
    spring.ai.ollama.chat.model=llama3
    
  4. ¡No toques el código Java! Gracias a la abstracción de Spring AI, tu AIController funcionará exactamente igual. Magia pura. ✨

¡Y eso es todo! Ya tienes tu primera aplicación con Inteligencia Artificial. ¿A que ha sido fácil?

Comentarios

Entradas populares de este blog

Navegar entre Actividades

En Android tenemos el concepto de Actividad (activity) que es una unidad de interacción con el usuario, es decir lo que podríamos decir que viene a ser una pantalla de una aplicación. A continuación veremos como navegar entre dos actividades o pantallas. Lo primero de todo será crear los componentes a los que vamos a navegar: Clase descendiente de Activity Layout que representará la nueva  pantalla Definir en el fichero Manifest de la aplicación la nueva actividad Realizar la invocación a la nueva actividad Clase descendiente de Activity: En principio una clase que herede de Activity y sobreescriba el método onCreate() para establecer cual es la vista debería ser suficiente. public class  Activity2  extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super .onCreate(savedInstanceState); setContentView(R.layout. layout2 ); } } Layout: El xml del layout puede contener cualquier componente q...

Instalación Android Studio

En la anterior entrada de Droide Code hacíamos una breve descripción de  Android Studio , el nuevo entorno de desarrollo de Google para Android. En el analizábamos las novedades que anunciaba Google sobre este nuevo IDE. Hoy mismo lo he instalado no sin algún que otro problema que paso a describir: Descargar el ejecutable del sitio oficial de  Android developer . El instalador está disponible para Windows, Linux y Mac Una vez tengamos el instalador y dependiendo de nuestro sistema operativo deberemos instalarlo al igual que cualquier otra aplicación. Una vez instalado tuve un pequeño problema a intentar ejecutarlo, ya que pulsaba sobre el ejecutable y no ocurría nada. Esto se debía a que en el pc en el que instalé la aplicación no tenía configurada la variable de entorno JAVA_HOME y no mostraba ningún mensaje que describiera dicho error. Para aseguraros de que es esto lo que os está ocurriendo podéis intentar...