Top 20 conceptos de IA en LLM: explicación detallada con ejemplos

1. Visión general

Si eres desarrollador Java que comienza a integrar LLM (ChatGPT, Gemini, Claude…) en tu sistema, te encontrarás con muchos términos extraños: token, embedding, RAG, fine-tuning, hallucination… Este artículo resume los 20 conceptos de IA más importantes relacionados con LLM, cada uno con una explicación breve y ejemplos ilustrativos (la mayoría en Java/Spring AI). Después de leerlo, tendrás suficiente vocabulario para leer la documentación de API de OpenAI, Anthropic o diseñar un sistema RAG básico.

2. Token y Tokenization

LLM no lee «caracteres» sino tokens — unidades más pequeñas que palabras, pueden ser una palabra, una parte de palabra o una puntuación. Tokenization es el proceso de dividir el texto en estos tokens antes de pasarlo al modelo.

Input:  "Spring Boot rất mạnh"
Tokens: ["Spring", " Boot", " rất", " mạnh"]  (4 tokens)

El número de tokens determina el costo de llamar a la API (facturación por token) y el límite de longitud de entrada/salida.

Nota: El vietnamita con tonos suele dividirse en más tokens que el inglés para la misma oración, por lo que el costo de llamar a la API para contenido en vietnamita suele ser más alto.

3. Embedding

Embedding es convertir un fragmento de texto en un vector de números reales (por ejemplo, 1536 dimensiones), de modo que dos fragmentos de texto con significados similares tengan vectores cercanos. Esta es la base para la búsqueda semántica (semantic search).

EmbeddingModel embeddingModel = ...; // bean configurado automáticamente por Spring AI
EmbeddingResponse response = embeddingModel.embedForResponse(
        List.of("Khách hàng muốn hủy đơn hàng"));
float[] vector = response.getResult().getOutput();
System.out.println(vector.length); // 1536

embedForResponse llama al modelo de embedding y devuelve el vector. Dos oraciones con significados similares tendrán vectores cercanos a pesar de ser en idiomas diferentes.

Para comparar la similitud semántica, usamos cosine similarity:

double cosineSimilarity(float[] a, float[] b) {
    double dot = 0, normA = 0, normB = 0;
    for (int i = 0; i < a.length; i++) {
        dot += a[i] * b[i];
        normA += a[i] * a[i];
        normB += b[i] * b[i];
    }
    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
}

@Test
void similarVectorsShouldScoreHigh() {
    float[] a = {1f, 0f, 1f};
    float[] b = {1f, 0.1f, 0.9f};
    assertThat(cosineSimilarity(a, b)).isGreaterThan(0.95);
}

Un valor cercano a 1 significa que dos vectores (y por lo tanto dos oraciones) tienen un significado muy similar.

4. Context Window

Context window es el número máximo total de tokens que el modelo «ve» en una sola llamada — incluyendo el prompt y la respuesta. Si se excede este límite, el modelo truncará el principio o devolverá un error.

GPT-4o:        128,000 tokens
Claude 3.5:    200,000 tokens
Gemini 1.5 Pro: 1,000,000 tokens

Para una aplicación chatbot con un histórico de conversación largo, debes proactivamente cortar/resumir el histórico antiguo antes de que se llene la ventana de contexto, de lo contrario perderás la información del principio de la conversación sin una advertencia clara.

5. Prompt y Prompt Engineering

Un prompt es el fragmento de texto que envías a un LLM para pedirle que haga algo. Prompt engineering es la técnica de diseñar prompts para que el modelo responda correctamente, en el formato deseado.

Primero, agrega la dependencia de Spring AI:

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

@Service
class OrderSummaryService {
    private final ChatClient chatClient;

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

    String summarize(String orderNote) {
        return chatClient.prompt()
                .user("Resumir la solicitud del cliente en 1 oración: " + orderNote)
                .call()
                .content();
    }
}

ChatClient es un wrapper de Spring AI que ayuda a llamar al modelo sin necesidad de gestionar HTTP manualmente. .user(...) establece el contenido del prompt, .call().content() devuelve la cadena de resultado.

6. System Prompt vs User Prompt

El system prompt es la instrucción «implícita» que define el rol y las reglas del modelo durante toda la conversación; el user prompt es la pregunta/solicitud específica del usuario.

chatClient.prompt()
        .system("Eres un asistente de atención al cliente de una tienda de zapatos. Siempre responde de manera breve y cortés.")
        .user("¿Cuándo se entregará mi pedido #1023?")
        .call()
        .content();

El system prompt solo necesita establecerse una vez, el user prompt cambia con cada solicitud. Separar estos dos tipos te ayuda a controlar la «personalidad» del modelo sin repetir instrucciones en cada pregunta.

7. Zero-shot, One-shot, Few-shot Learning

Estas son formas de proporcionar (o no) ejemplos de muestra en el prompt para que el modelo aprenda a responder en el formato deseado, sin necesidad de hacer fine-tuning al modelo.

Zero-shot: Sin ejemplos, solo hay descripción de requisitos.
Few-shot:  Hay 2-5 ejemplos entrada -> salida de muestra antes de hacer la pregunta real.

String fewShotPrompt = """
    Clasificar sentimiento de reseña (positivo/negativo):
    Reseña: "Envío rápido, buena calidad" -> positivo
    Reseña: "Producto defectuoso, envío 1 semana tarde" -> negativo
    Reseña: "%s" ->
    """.formatted(userReview);

Few-shot generalmente proporciona resultados más estables que zero-shot para tareas de clasificación/formato específico, aunque cuesta más tokens en cada llamada.

8. Chain-of-Thought (CoT)

CoT es una técnica que pide al modelo que «piense paso a paso» antes de dar la respuesta final, lo que ayuda a mejorar la precisión en problemas que requieren razonamiento (matemáticas, lógica).

chatClient.prompt()
        .user("""
            Un pedido tiene 3 productos con precio 120k, 85k, 45k, descuento 10%.
            Calcula paso a paso y proporciona el monto total final.
            """)
        .call()
        .content();

Cuando se le pide que lo haga «paso a paso», el modelo tiende a desglosar el problema en cálculos más pequeños, reduciendo la probabilidad de error en comparación con preguntar directamente «¿cuál es el total?».

9. Temperature y Top-p

Temperature y top-p son dos parámetros que ajustan el grado de «aleatoriedad» cuando el modelo elige la siguiente palabra. Temperature baja → respuestas consistentes, repetitivas; alta → más creativas pero más propensas a desviarse del tema.

ChatOptions options = OpenAiChatOptions.builder()
        .withTemperature(0.2)
        .withTopP(0.9)
        .build();

temperature = 0.0  -> apropiado: extracción de datos, respuestas precisas
temperature = 0.8  -> apropiado: escritura creativa, lluvia de ideas

Nota: Para tareas que requieren resultados reproducibles (por ejemplo, pruebas automatizadas), debes establecer temperature = 0 para reducir la variabilidad entre llamadas.

10. Attention Mechanism

Attention es un mecanismo que permite al modelo, al procesar una palabra, «ver» todas las demás palabras en la oración y calcular automáticamente los pesos para ver cuál está más relacionada. Esta es la razón por la que el modelo puede entender contextos lejanos, por ejemplo, a qué sustantivo se refiere un pronombre.

Oración: "El pedido fue cancelado porque el cliente cambió de idea, se le reembolsó."
Attention ayuda al modelo a vincular "se" -> "El pedido", no "el cliente".

No codificas directamente el mecanismo de attention cuando usas la API, pero comprenderlo ayuda a explicar por qué el modelo a veces «olvida» el contexto de oraciones muy lejanas o muy largas.

11. Transformer Architecture

Transformer es la arquitectura de red neuronal que subyace en casi todos los LLM actuales, usa attention para procesar oraciones completas en paralelo en lugar de secuencialmente como en las antiguas RNN, lo que permite un entrenamiento más rápido en datos masivos.

Input tokens -> Embedding -> [Attention + Feed-Forward] x N capas -> Output probabilities

El número de capas (N) y el número de parámetros (parameters) determinan el «tamaño» del modelo — GPT-4, Claude, Llama son todas variantes de Transformer con diferente número de capas y métodos de entrenamiento.

12. Fine-tuning

Fine-tuning es continuar entrenando un modelo que ya existe (pretrained) con datos propios, para especializarlo en una tarea específica (por ejemplo: responder con el tono correcto de la marca).

{"messages": [
  {"role": "user", "content": "¿Cuándo se entrega el pedido #203?"},
  {"role": "assistant", "content": "El pedido #203 está en camino, se espera que llegue hoy."}
]}

Este archivo JSONL es una línea de datos de entrenamiento de muestra para fine-tuning — cada línea es un par de diálogo de muestra, envías miles de líneas así a la API de fine-tuning del proveedor.

Cuándo NO usarlo: si solo necesitas que el modelo responda siguiendo algunas reglas simples, prompt engineering o RAG son mucho más baratos y rápidos que fine-tuning.

13. LoRA (Low-Rank Adaptation)

LoRA es una técnica de fine-tuning económica: en lugar de actualizar todos los billones de parámetros del modelo original, LoRA solo entrena algunos pequeños matrices «inyectados» en las capas, manteniendo el modelo original sin cambios.

Modelo original: 7 mil millones de parámetros (congelados, sin cambios)
Adaptador LoRA: ~10-50 millones de parámetros (entrenados)

Gracias a esto, LoRA permite hacer fine-tune de modelos grandes en una GPU ordinaria, y puedes «conectar y desconectar» múltiples adaptadores diferentes para múltiples casos de uso en el mismo modelo base.

14. Quantization

Quantization es reducir la precisión numérica de los parámetros del modelo (por ejemplo, de float32 a int8/int4) para reducir el tamaño y acelerar la inferencia, sacrificando un poco de precisión.

FP32: 7B parámetros x 4 bytes = ~28 GB RAM
INT4: 7B parámetros x 0.5 byte = ~3.5 GB RAM

Quantization es la razón por la que puedes ejecutar un LLM de 7 mil millones de parámetros en una laptop ordinaria en lugar de necesitar un servidor GPU dedicado — a cambio, la calidad de las respuestas disminuye ligeramente.

15. RAG (Retrieval-Augmented Generation)

RAG es una técnica que combina búsqueda (retrieval) de datos internos con LLM: antes de responder, el sistema busca los fragmentos de texto más relevantes (mediante embedding) y los incluye en el prompt como «contexto», permitiendo que el modelo responda basándose en tus datos específicos sin necesidad de fine-tuning.

List<Document> relevantDocs = vectorStore.similaritySearch(
        SearchRequest.query("política de cambio y devolución").withTopK(3));

String context = relevantDocs.stream()
        .map(Document::getContent)
        .collect(Collectors.joining("\n---\n"));

String answer = chatClient.prompt()
        .system("Solo responde basándote en el contexto proporcionado.")
        .user("Contexto:\n" + context + "\n\nPregunta: ¿En cuántos días puedo devolver?")
        .call()
        .content();

similaritySearch busca los 3 fragmentos de documento más semánticamente similares a la pregunta, los incluye en el prompt y luego lo envía al modelo. Gracias a esto, la respuesta se adhiere a las políticas reales, no al conocimiento «general» que el modelo aprendió durante el pretraining.

16. Vector Database

Vector database es donde se almacenan las embeddings junto con metadatos, soportando búsqueda rápida de «k vecinos más cercanos» (k-NN) en millones de vectores — componente esencial para que RAG funcione a escala (Pinecone, Milvus, PGVector…).

CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    content TEXT,
    embedding VECTOR(1536)
);

SELECT content FROM documents
ORDER BY embedding <-> '[0.01, -0.02, ...]'
LIMIT 3;

El operador <-> (proporcionado por la extensión pgvector) calcula la distancia entre el vector de la pregunta y los vectores almacenados, devolviendo los registros más cercanos — esto es exactamente el paso similaritySearch en la sección 15.

17. Function Calling / Tool Use

Function calling permite que el LLM «pida» a tu aplicación que llame a una función específica (consultar precio, consultar clima, consultar BD) cuando lo considera necesario, en lugar de inventar datos.

@Tool(description = "Obtener estado del pedido por código de pedido")
String getOrderStatus(String orderId) {
    return orderRepository.findStatusById(orderId);
}

chatClient.prompt()
        .user("¿En qué estado está el pedido #1023?")
        .tools(this)
        .call()
        .content();

Al enviar la pregunta, el modelo reconoce automáticamente que necesita llamar a getOrderStatus, Spring AI ejecuta la función Java real, obtiene el resultado y se lo devuelve al modelo para componer la respuesta final — el modelo ya no tiene que «adivinar» el estado del pedido.

18. AI Agent

Agent es un sistema que usa LLM como «cerebro» para planificar automáticamente, llamar a múltiples herramientas en secuencia, observar resultados e iterar hasta completar el objetivo — diferente de un chatbot que solo responde una vez.

Usuario: "Verifica el pedido #1023, si lleva más de 3 días de retraso envía un email de disculpa al cliente."

El agente ejecuta automáticamente:
1. Llama a la herramienta getOrderStatus("1023")
2. Calcula días de retraso
3. Si > 3 -> llama a la herramienta sendEmail(...)
4. Devuelve un informe al usuario

Los agentes suelen construirse usando un bucle de «pensar → actuar → observar» (patrón ReAct), combinando múltiples function calls sucesivos para procesar una tarea con múltiples pasos.

19. Hallucination

Hallucination es cuando el modelo responde con confianza pero la información es incorrecta o completamente inventada — por ejemplo, citar una ley inexistente o recordar incorrectamente una API que no existe.

Usuario: "¿Cómo funciona el método `OrderService.cancelAndRefund()`?"
Modelo: "Este método automáticamente reembolsa en 24h..." (pero este método no existe en el codebase)

La forma más común de reducir hallucinations es usar RAG (sección 15) para que el modelo se adhiera a documentos reales, y pedirle que responda «no sé» cuando el contexto no proporcione suficiente información, en lugar de hacer sus propias inferencias.

20. Guardrails

Guardrails es un conjunto de capas de control (filtrar entrada/salida, validar formato, bloquear contenido sensible) colocadas alrededor del LLM para garantizar que el sistema sea seguro y cumpla con los estándares antes de devolver resultados al usuario final.

String output = chatClient.prompt().user(userInput).call().content();

if (containsPersonalData(output) || !isValidJson(output)) {
    throw new UnsafeModelOutputException("Output no cumple con los estándares de guardrail");
}

Los guardrails pueden estar en la entrada (prevenir prompt injection, contenido malicioso) o en la salida (validar formato JSON, ocultar números de tarjeta) — no debes omitir este paso cuando pongas LLM en producción, incluso si el modelo «parece» responder correctamente durante las pruebas.

21. RLHF (Reinforcement Learning from Human Feedback)

RLHF es una técnica de entrenamiento de modelo basada en retroalimentación humana: los humanos clasifican múltiples respuestas del modelo, de lo cual se entrena un «modelo de recompensa» para continuar optimizando el modelo original para que las respuestas sean más útiles y seguras.

Paso 1: El modelo genera 3-4 respuestas para la misma pregunta
Paso 2: Los humanos clasifican: mejor -> peor
Paso 3: Se entrena un modelo de recompensa aprendiendo a «calificar» como lo hacen los humanos
Paso 4: Se usa el modelo de recompensa para fine-tunear el LLM mediante reinforcement learning

RLHF es la razón por la que ChatGPT, Claude responden con un «tono» educado y rechazan solicitudes peligrosas — diferente del modelo base que solo fue entrenado para «predecir la siguiente palabra» pura y simplemente.

22. Conclusión

Los 20 conceptos anteriores son el vocabulario mínimo para trabajar seriamente con LLM: desde capas bajas (token, embedding, attention) hasta capas de aplicación (RAG, function calling, agent, guardrails). No necesitas entender profundamente las matemáticas de Transformer para integrar LLM en tu sistema Spring Boot, pero comprender correctamente estos conceptos te ayuda a elegir la solución adecuada — por ejemplo, saber cuándo usar RAG en lugar de fine-tuning, o cuándo necesitas guardrails en lugar de confiar ciegamente en la salida del modelo.