Recuperación para aplicaciones con LLM
Unos 38 minutos de lectura, con 10 ejemplos en 10 secciones.
Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros
Traducido del libro en inglés, edición 2026.11.10. Lee el original
En esta página
- Coloca los productos recuperados en el prompt
- Puntúa cada respuesta según los productos que cita
- Verifica cada cita contra el contexto
- Comprueba lo que respalda el producto citado
- Mide el contexto y luego la respuesta
- Elige la unidad recuperable
- Lee las búsquedas de un agente en su traza
- Compara los recuperadores detrás de la herramienta del agente
- Qué sale mal en producción
- Decisiones que tomó este capítulo
Al final de este capítulo podrás medir la recuperación que sustenta a un LLM que responde a partir de ella: puntuar una respuesta según los productos que cita, comprobar cada cita frente a lo que devolvió la recuperación, medir los productos que lee el LLM, elegir qué indexar como una unidad recuperable y leer las búsquedas de un agente a partir del registro de sus llamadas a herramientas.
Cada búsqueda en la tienda termina en una lista ordenada de muebles y artículos para el hogar que los compradores leen por su cuenta. Un asistente de compras podría responder con palabras en su lugar. El comprador escribe lo que busca, y un LLM recomienda unos pocos productos y cita cada uno por su ID. El prompt le indica al LLM que recomiende solo los productos que la búsqueda le presenta, así que el asistente no puede ser mejor que su recuperación. Lo mismo vale para un agente, un LLM que ejecuta las búsquedas por sí mismo y decide cuántas realizar.
Por eso este capítulo puntúa las respuestas, las citas, el contexto y las búsquedas del agente frente a los juicios humanos de la tienda. Cada hallazgo sobre el LLM es válido para este modelo, estos prompts y las 30 consultas de prueba, no para los LLM en general. En el caso de una respuesta, el LLM leyó el nombre, la clase, la categoría, la descripción y los atributos de cada producto como texto, mientras que la herramienta de búsqueda del agente le muestra menos. Los jueces humanos también vieron la imagen y la página web de cada producto (lo que vio el LLM). La recuperación semántica ordena según los embeddings registrados de Snowflake/snowflake-arctic-embed-m-v1.5, y BM25 es la referencia sin stemming del libro, lib.lexical.
Planificamos 2 comparaciones, todas sobre las consultas de prueba, antes de abrir cualquier resultado, y en cada una la recuperación semántica se enfrenta a BM25:
- detrás de las respuestas registradas, sobre la proporción de productos citados en cada respuesta que las personas juzgaron exactos (Puntuar cada respuesta)
- detrás de la herramienta de búsqueda del agente, sobre la precisión@3 de los productos que elige (Comparar los recuperadores)
Las 2 comparaciones planificadas dividen el 0.05 del libro, así que cada una necesita una prueba de permutaciones pareada con un valor p por debajo de 0.025. El capítulo también informa la prueba t pareada y un intervalo bootstrap del 97.5 %. Todo lo demás sobre las consultas de prueba es una descripción o se indica como exploratorio.
Coloca los productos recuperados en el prompt
Retrieval-augmented generation (RAG), el diseño detrás de un asistente de compras, combina un LLM con un recuperador. Para cada solicitud, el recuperador encuentra unos pocos textos en un índice, y el LLM escribe su respuesta a partir de ellos. Los modelos RAG de Lewis et al. guardan su memoria no paramétrica como un índice vectorial denso de Wikipedia, que un recuperador neuronal preentrenado busca. Esos autores también señalan como problemas abiertos de investigación dos problemas de los modelos de lenguaje por sí solos: dar procedencia de sus decisiones y actualizar su conocimiento del mundo (Lewis et al., 2020). Una tienda tiene ambos problemas: su catálogo cambia, y una respuesta debe indicar qué productos recomienda. El texto recuperado entra en el prompt, la entrada que lee el modelo, y el texto recuperado dentro de un prompt es el contexto. La ventana de contexto de un modelo es el máximo de tokens que puede leer, un número fijo de fragmentos de palabra de su propio vocabulario.
¿Por qué no poner todo el catálogo en el prompt y prescindir de la recuperación? Tiene que caber, y aun cuando quepa, los modelos no leen de manera uniforme un prompt largo. Liu et al. comprobaron que los modelos suelen funcionar mejor cuando la información relevante está al principio o al final de la entrada, y que el rendimiento baja de forma notable cuando está en medio de un contexto largo (Liu et al., 2024). Un estudio posterior llama a esto el efecto de perderse en medio (LiM). Encuentra que el efecto es más fuerte cuando las entradas ocupan hasta el 50 % de la ventana de contexto de un modelo, y cerca del límite cede paso a un sesgo hacia el final (Veseli et al., 2025). Tampoco es siempre mejor tener más pasajes. Según Jin et al., al dar a LLM de contexto largo más pasajes recuperados, la calidad de la salida primero mejora y luego empeora, y ellos consideran que los negativos difíciles recuperados son un factor clave de ese deterioro, pasajes que parecen relevantes sin serlo (Jin et al., 2024). La entrada de ingeniería de un proveedor sugiere lo contrario para colecciones pequeñas: poner en el prompt toda una base de conocimiento cuando contiene menos de 200,000 tokens, unas 500 páginas de material (Anthropic, 2024). Es una regla práctica de un proveedor, no una medición.
El LLM de la tienda es el modelo abierto gemma4:12b-it-q4_K_M. Sus grabaciones, recordings/rag_answers.py y recordings/agent_trace.py, hicieron cada llamada al modelo una sola vez, como hizo la grabación del capítulo 4, con temperatura 0, una semilla fija y el razonamiento desactivado (capítulo 9), y guardaron las respuestas, que los ejemplos leen mediante lib.recorded. El manifiesto de cada grabación, el archivo que la describe, indica que la licencia del modelo es Apache-2.0.
Las respuestas grabadas de la tienda (Evalúa cada respuesta) colocan cinco productos en cada prompt, después de estas instrucciones: "You help shoppers at an online furniture and home-goods store. Using only the products listed below, answer the shopper. Recommend up to three products that fit, cite each one by its ID, and say plainly if none of them fit. Don't mention products that aren't listed." ¿A cuántos prompts equivale el catálogo? Contar sus palabras tal como las lee el LLM responde a esa pregunta.
1"""Counts the catalog's words as the LLM reads each product, then sets them against a median prompt of the2instructions and five products, and against the recording's context window. The point rests on the "catalog3against one prompt" line."""4from statistics import median56from lib.agreement import as_the_llm_saw7from lib.recorded import manifest, rag_answers8from lib.store import load_products910recording = manifest("rag-answers")11# num_ctx is the context window, in tokens, that the recording set12window = recording["options"]["num_ctx"]13print("model:", recording["model"])14print("licence in the manifest:", recording["model_licence"])15print("instructions:", recording["prompts"].split("\n")[0])16print("context window the recording set, in tokens:", window)1718products = load_products()19# words are whitespace-separated pieces, since this model's tokenizer isn't in the book's lib20words = {product_id: len(f"ID: {product_id}\n{as_the_llm_saw(product)}".split()) # each product as the LLM read it21 for product_id, product in products.iterrows()}22instructions = len(recording["prompts"].split()) # the prompt's own words, without the query23# one prompt per recorded answer: the instructions, then the five products' words24prompts = [instructions + sum(words[p] for p in ids) for ids in rag_answers()["context_ids"]]25catalog = sum(words.values())26print(f"words in the catalog as the LLM reads it: {catalog:,}")27print(f"words in one prompt with five products, median: {median(prompts):,.0f}")28print(f"the catalog against one prompt: {catalog / median(prompts):,.0f} times")29print(f"the catalog against the recording's window, at one token per word: {catalog / window:,.0f} times")30print(f"the catalog against 200,000 tokens, at one token per word: {catalog / 200_000:.1f} times")
python catalog-against-the-context.pymodel: gemma4:12b-it-q4_K_M
licence in the manifest: Apache-2.0
instructions: You help shoppers at an online furniture and home-goods store. Using only the products listed below, answer the shopper. Recommend up to three products that fit, cite each one by its ID, and say plainly if none of them fit. Don't mention products that aren't listed.
context window the recording set, in tokens: 8192
words in the catalog as the LLM reads it: 1,091,544
words in one prompt with five products, median: 536
the catalog against one prompt: 2,035 times
the catalog against the recording's window, at one token per word: 133 times
the catalog against 200,000 tokens, at one token per word: 5.5 times
Aun con la muestra del libro que recorta las descripciones de los productos a unos 400 caracteres (ficha de datos), el catálogo contiene 1,091,544 palabras, y un prompt con cinco productos contiene una mediana de 536 palabras. El catálogo es 2,035 times más grande que un prompt.
Sin un tokenizador para este modelo, los recuentos son de palabras. La grabación fijó una ventana de contexto de 8192 tokens. Si cada palabra fuera un solo token, el catálogo llenaría esa ventana 133 times veces, y los 200,000 tokens del proveedor se superarían 5.5 times de veces. La tienda tiene que recuperar.
Regla práctica: Coloca en el prompt unos pocos elementos recuperados, no la colección, y elige cuántos midiendo las respuestas a consultas de entrenamiento con varios tamaños, porque más contexto puede ayudar o perjudicar. La grabación de la tienda solo respondió las consultas de prueba, cinco productos cada una, así que cinco es aquí un valor fijo, no uno medido. Considera enviar toda la colección solo cuando quepa holgadamente dentro de la ventana, y entonces compárala con la recuperación en las mismas consultas.
Puntúa cada respuesta según los productos que cita
Un LLM al que se le pide responder a partir de un contexto solo debería recomendar lo que el contexto contiene, y la comprobación de IDs verifica que así sea. Si ningún producto exacto está en el contexto, ningún prompt logra que una respuesta fundamentada recomiende uno. La recuperación fija un techo para la respuesta, y también importa lo demás que contiene el contexto.
Cuconasu et al. encontraron que los documentos mejor puntuados por el recuperador que no son directamente relevantes, es decir, los que no contienen la respuesta, perjudican las respuestas. Más sorprendentemente, añadir documentos aleatorios al prompt mejoró la precisión del LLM hasta en un 35% (Cuconasu et al., 2024). Los productos que parecen adecuados sin serlo son distractores, la versión de la tienda de esos pasajes. En la respuesta a preguntas, Joren et al. encontraron un patrón relacionado. Cuando el contexto carecía de lo necesario, los modelos más grandes que probaron, Gemini 1.5 Pro, GPT 4o y Claude 3.5, a menudo daban respuestas incorrectas en lugar de abstenerse. Los más pequeños, entre ellos Mistral 3 y Gemma 2, con frecuencia alucinaban o se abstenían incluso cuando el contexto era suficiente (Joren et al., 2024).
Una cita aquí es el ID que una respuesta da para un producto que recomienda. Con los juicios, puedes puntuar una respuesta sin leerla: consulta la calificación de cada producto citado. La proporción exacta de una respuesta es la parte de sus productos citados que las personas juzgaron exactos. Una respuesta que no cita nada obtiene 0, porque no ofrece al comprador nada que encaje, lo haya decidido bien o no. Un recuento aparte de las respuestas que no recomiendan nada cubre ese caso.
exact share = (cited products judged exact) / (products cited), 0 when the answer cites nothing
La grabación de la tienda respondió a cada consulta de prueba tres veces, con la consulta a continuación de "Estoy buscando". Cada respuesta provino de un contexto distinto de cinco productos: los 5 primeros de la recuperación semántica, los 5 primeros de BM25 o cinco productos extraídos al azar con una semilla fija. El contexto aleatorio es un suelo, un contexto que ningún recuperador eligió. El modelo, el prompt y la consulta se mantienen iguales, de modo que las respuestas solo difieren porque sus contextos difieren. Leímos cada contexto tal como lo guardó la grabación, en el orden en que el LLM lo leyó. Los contextos de BM25 conservan los productos empatados en el orden propio de bm25s, no por product_id como lo hace lib.lexical, de modo que 7 de las 30 consultas de prueba reciben un contexto que difiere de lo que devuelve lib.lexical, 6 de ellas solo en el orden. La grabación pidió JSON con la respuesta y los IDs citados en campos separados. score_answers en lib.generation puntúa cada respuesta según las calificaciones humanas. La comparación de esas puntuaciones es la primera de las comparaciones previstas del capítulo, y se considera establecida si su valor p de permutación está por debajo de 0.025.
¿Cuántas respuestas no recomendarán nada, dados cinco productos aleatorios y un prompt que indica al LLM que diga claramente si ninguno encaja?
1"""Scores the recorded answers on the human grades, context by context, and makes the first planned comparison. The2point rests on the mean exact share and recommend-nothing lines, and on the permutation p-value of the3comparison."""4from lib.generation import PLANNED_TEST_COMPARISONS, THRESHOLD, report_planned, score_answers5from lib.lexical import LexicalSearch6from lib.recorded import rag_answers7from lib.store import load_products, load_queries, qrels89answers = rag_answers()10stored = answers[answers["context"] == "bm25"].set_index("query_id")["context_ids"] # as the LLM read them11rerun = LexicalSearch(load_products()).run(load_queries("test"), k=5) # ties by product_id12differ = [q for q in stored.index if stored[q] != rerun[q]]13print("bm25 contexts that differ from lib.lexical:", len(differ))14# a match as sets means the same five products in another order: a tie-break, not a different context15print("bm25 contexts that differ from lib.lexical only in order:", sum(set(stored[q]) == set(rerun[q]) for q in differ))1617scores = score_answers(answers, qrels("test")) # one row per test query and context, on human grades18for context, rows in scores.groupby("context", sort=False):19 # held: the context holds an exact product; nothing: the answer cites no product20 held, nothing = rows["exact in context"] > 0, rows["cited"] == 021 print(f"{context}, unjudged products in the contexts: {rows['unjudged in context'].sum()}")22 print(f"{context}, contexts with an exact product: {held.sum()}")23 print(f"{context}, answers that cite an exact product: {(rows['exact cited'] > 0).sum()}")24 print(f"{context}, products cited: {rows['cited'].sum()}")25 print(f"{context}, cited products that are exact: {rows['exact cited'].sum()}")26 print(f"{context}, mean exact share: {rows['exact share'].mean():.3f}")27 print(f"{context}, answers that recommend nothing: {nothing.sum()}")28 print(f"{context}, recommend nothing, with an exact product in the context: {(nothing & held).sum()}")29 print(f"{context}, recommend something, with no exact product in the context: {(~nothing & ~held).sum()}")30 near = rows[~held] # answers whose context held no exact product31 print(f"{context}, products cited with no exact product in the context: {near['cited'].sum()}")32 print(f"{context}, of those, partial: {near['partial cited'].sum()}")33 print(f"{context}, unjudged products cited: {rows['unjudged cited'].sum()}")34print("answers that cite more exact products than their context holds:",35 (scores["exact cited"] > scores["exact in context"]).sum())3637print("planned test comparisons:", len(PLANNED_TEST_COMPARISONS))38print(f"p-value threshold: {THRESHOLD:.3f}")39share = scores.pivot(index="query_id", columns="context", values="exact share")40# the first planned comparison: semantic minus BM25 on the exact share, tested at THRESHOLD41report_planned("answers, semantic over bm25", share["semantic"], share["bm25"])
python rag-answers-by-context.pybm25 contexts that differ from lib.lexical: 7
bm25 contexts that differ from lib.lexical only in order: 6
semantic, unjudged products in the contexts: 0
semantic, contexts with an exact product: 25
semantic, answers that cite an exact product: 22
semantic, products cited: 80
semantic, cited products that are exact: 60
semantic, mean exact share: 0.658
semantic, answers that recommend nothing: 2
semantic, recommend nothing, with an exact product in the context: 1
semantic, recommend something, with no exact product in the context: 4
semantic, products cited with no exact product in the context: 11
semantic, of those, partial: 11
semantic, unjudged products cited: 0
bm25, unjudged products in the contexts: 10
bm25, contexts with an exact product: 24
bm25, answers that cite an exact product: 23
bm25, products cited: 73
bm25, cited products that are exact: 52
bm25, mean exact share: 0.639
bm25, answers that recommend nothing: 3
bm25, recommend nothing, with an exact product in the context: 0
bm25, recommend something, with no exact product in the context: 3
bm25, products cited with no exact product in the context: 7
bm25, of those, partial: 7
bm25, unjudged products cited: 1
random, unjudged products in the contexts: 147
random, contexts with an exact product: 1
random, answers that cite an exact product: 1
random, products cited: 1
random, cited products that are exact: 1
random, mean exact share: 0.033
random, answers that recommend nothing: 29
random, recommend nothing, with an exact product in the context: 0
random, recommend something, with no exact product in the context: 0
random, products cited with no exact product in the context: 0
random, of those, partial: 0
random, unjudged products cited: 0
answers that cite more exact products than their context holds: 0
planned test comparisons: 2
p-value threshold: 0.025
answers, semantic over bm25, mean difference: 0.019
answers, semantic over bm25, wins, losses, ties: 4, 5, 21
answers, semantic over bm25, permutation p: 0.765
answers, semantic over bm25, established at 0.025: no
answers, semantic over bm25, t-test p: 0.715
answers, semantic over bm25, t-test agrees: yes
answers, semantic over bm25, 97.5% interval: -0.078 to 0.161
answers, semantic over bm25, interval agrees: yes
| Medida | Semántica | BM25 | Aleatoria |
|---|---|---|---|
| Contextos con un producto exacto | 25 | 24 | 1 |
| Respuestas que citan un producto exacto | 22 | 23 | 1 |
| Productos citados | 80 | 73 | 1 |
| Productos citados que son exactos | 60 | 52 | 1 |
| Proporción exacta media | 0.658 | 0.639 | 0.033 |
| Respuestas que no recomiendan nada | 2 | 3 | 29 |
Con productos aleatorios, el LLM no recomienda nada en 29 de las 30 respuestas, así que este modelo y este prompt no forzaron una recomendación a partir de productos aleatorios. El único producto que cita es exacto, y el sorteo aleatorio casualmente lo incluyó. Los contextos aleatorios también contienen 147 productos que nadie juzgó, que cuentan como no exactos. Esperamos que pocos encajen, pero ningún juicio lo confirma.
El techo se cumple: 0 respuestas citan más productos exactos de los que contiene su contexto. Los casos cercanos son otra cuestión. Cuando el contexto no tenía ningún producto exacto, la respuesta aun así recomendó algo 4 veces con la recuperación semántica y 3 veces con BM25, en lugar de decir que ningún producto encaja exactamente.
Todos los productos que esas respuestas citan son parciales: 11 de 11 con la recuperación semántica y 7 de 7 con BM25, el tipo de producto correcto con un modificador equivocado. Que eso cuente como fallo depende de si el comprador quiere coincidencias aproximadas.
El fallo inverso es más raro: las respuestas no recomiendan nada aunque su contexto contenía un producto exacto, 1 con la recuperación semántica y 0 con BM25.
Los contextos de BM25 contienen 10 productos sin juzgar, y los de la recuperación semántica contienen 0. La puntuación solo lee los productos citados, y las respuestas de BM25 citan 1 producto sin juzgar, que cuenta como no exacto.
La ventaja de la recuperación semántica en nDCG@10 está establecida (capítulo 3). En la primera comparación prevista, sin embargo, su diferencia con BM25 en la proporción exacta media, 0.019, no está establecida: el valor p de permutación es 0.765 (ambas comparaciones).
Regla práctica: Puntúa cada respuesta según las calificaciones humanas de sus productos citados, y reporta junto a ella cuántas respuestas no recomiendan nada, separadas según si el contexto tenía un producto exacto. Mantén un contexto aleatorio como suelo siempre que cambies el modelo o el prompt: una respuesta que recomienda algo a partir de productos aleatorios ha inventado un encaje. Pon también a prueba la mejora de un recuperador en las respuestas, porque una mejora en el ranking no tiene por qué trasladarse a ellas.
Verifica cada cita contra el contexto
La fundamentación significa que una respuesta se apoya en el contexto que recibió, como la participación exacta supone, y no en lo que el modelo recuerda o inventa. Las citas hacen comprobable la fundamentación, y la atribución pregunta si una fuente citada respalda la afirmación a la que está vinculada. Las auditorías encuentran que las citas a menudo no lo hacen. En una auditoría de 2023 sobre motores de búsqueda generativos, solo el 51.5 % de las oraciones generadas estaban totalmente respaldadas por sus citas, y solo el 74.5 % de las citas respaldaban la oración a la que estaban asociadas (Liu et al., 2023). En ELI5, las preguntas de formato largo del benchmark ALCE, tomadas del foro de Reddit Explain Like I'm Five, incluso los mejores modelos de 2023 carecían de respaldo completo de citas el 50 % de las veces (Gao et al., 2023).
Verifica las citas en dos niveles, del más barato al más caro. El primero es exacto y no necesita ningún modelo: cada ID citado debe ser uno que el contexto contuviera. Un ID que no está en el contexto nombra un producto que el modelo recordó o inventó, y en cualquiera de los dos casos la respuesta no está fundamentada. El segundo nivel pregunta si el texto del producto citado respalda lo que la respuesta dice sobre él, lo que requiere un lector (Comprueba lo que respalda el producto citado).
El esquema de la grabación pedía los IDs citados como una lista de enteros en un campo propio (schemas en el manifiesto). El esquema describe la forma del campo; no dice qué IDs van en él, ni cuántos. La verificación lee cada respuesta registrada frente a su contexto, y compara el campo con los IDs del contexto que el texto de la respuesta escribe. El texto no puede revelar un ID de fuera del contexto, que se vería como cualquier otro número que una respuesta escribe, como una talla. Por eso los IDs pertenecen a un campo:
1"""Checks every recorded answer's cited IDs against its context, and its text against its cited field. The point2rests on the zero counts for IDs outside the context and for disagreeing text, and on the count of answers that3cite more than three products."""4from lib.generation import ids_in_text5from lib.recorded import rag_answers67answers = rag_answers()8outside = answers.apply(lambda a: [p for p in a["cited"] if p not in a["context_ids"]], axis=1)9# an ID cited twice makes the list longer than the set of its IDs10repeated = answers["cited"].map(lambda cited: len(cited) != len(set(cited)))11# the text is searched only for the context's IDs, so an ID from outside it can't match12written = answers.apply(lambda a: ids_in_text(a["answer"], a["context_ids"]), axis=1) # IDs the text writes out13print("answers:", len(answers))14print("answers that cite an ID outside their context:", (outside.map(len) > 0).sum())15print("answers that cite one ID twice:", repeated.sum())16print("answers that cite nothing:", (answers["cited"].map(len) == 0).sum())17# the prompt asks for up to three products18print("answers that cite more than three products:", (answers["cited"].map(len) > 3).sum())19print("answers whose text and cited IDs differ:", (written != answers["cited"].map(set)).sum())
python citations-inside-the-context.pyanswers: 90
answers that cite an ID outside their context: 0
answers that cite one ID twice: 0
answers that cite nothing: 34
answers that cite more than three products: 3
answers whose text and cited IDs differ: 0
En las 90 respuestas registradas, la verificación encuentra 0 respuestas que citan un ID fuera de su contexto, 0 que citan un mismo ID dos veces, y 0 cuyo texto y campo no coinciden.
34 respuestas no citan nada. La instrucción que sí incumplen las respuestas es cuántos productos recomendar: 3 respuestas citan más de tres productos, aunque el prompt dice "Recomienda hasta tres".
En esta grabación, la verificación de IDs no encuentra ninguna cita sin fundamento. Ese es el resultado que buscas, y no hay razón para abandonar la verificación: cuesta una búsqueda en un conjunto por respuesta, y otro modelo, prompt o longitud de contexto podría hacerla fallar. Superarla indica solo que cada producto recomendado estaba delante del modelo, no que encaje.
Regla práctica: Ejecuta la verificación de IDs en cada respuesta, sin conexión y antes de que un comprador la vea, y trata un ID fuera del contexto como una respuesta fallida: descártala o vuelve a generarla, y nunca la muestres. Pide las citas en un campo propio para que la verificación no tenga que analizar prosa, y comprueba que el texto y el campo coinciden. Cuenta las instrucciones que las respuestas incumplen, como el número de recomendaciones, y aplica en código las que importan.
Comprueba lo que respalda el producto citado
El segundo nivel de verificación pregunta si el texto citado respalda la afirmación. La fidelidad es la proporción de afirmaciones de una respuesta que el contexto respalda. En palabras de la documentación de Ragas (sus páginas no indican versión; las que se abrieron tienen fecha 2025-12-09), "Una respuesta se considera fiel si todas sus afirmaciones pueden respaldarse con el contexto recuperado" (documentación de Ragas). Comprobarlo requiere una persona. ALCE usa un modelo de inferencia en lenguaje natural (NLI, por sus siglas en inglés), la tarea de decidir si un texto implica otro: un modelo T5-11B ajustado con una colección de conjuntos de datos NLI. La exhaustividad de las citas (citation recall) de una afirmación vale 1 solo cuando sus citas, en conjunto, la implican (Gao et al., 2023, secciones 3.2 y 3.3). Un LLM también puede juzgar el respaldo, con límites. En la pista RAG de 2024 de TREC, las evaluaciones compartidas de la Text REtrieval Conference, Thakur et al. comprobaron que las predicciones humanas y las de GPT-4o coincidieron por completo en una escala de tres niveles en el 56 % de los juicios hechos desde cero, y en el 72 % cuando las personas partieron de la etiqueta de respaldo de GPT-4o y la editaron. También hallaron que un juez humano independiente se correlacionaba más con GPT-4o que otra persona, así que parte del desacuerdo se da entre personas (Thakur et al., 2025).
El respaldo no es la relevancia. Una cita puede ser fiel al texto del producto y aun así recomendar el producto equivocado: el texto dice lo que afirma la respuesta, pero el producto no es el que buscaba la persona compradora. Solo los juicios lo detectan.
Empieza revisando a mano una de las respuestas de la tienda, la de la consulta de prueba medium size chandelier del contexto semántico. Después cuenta las calificaciones humanas de cada producto citado en las respuestas registradas de los contextos semántico y BM25.
1"""Reads one recorded answer by hand, checking its claim against the cited product's text and the judges' label,2then counts the grades of every product the two retrievers' answers cite. The point rests on the partial label,3the exact count in this answer's context, and the breakdown of cited products."""4from collections import Counter56from lib.agreement import LABELS7from lib.recorded import rag_answers8from lib.store import load_products, load_queries, qrels910products, queries, judgments = load_products(), load_queries("test"), qrels("test")11answers = rag_answers().set_index(["query_id", "context"])1213chandelier, claim = 58, "medium-sized" # one answer, read by hand14answer, judged = answers.loc[(chandelier, "semantic")], judgments[chandelier]15# the answer cites one product, so index 0 is that product16cited = answer["cited"][0]17print("query:", queries.at[chandelier, "query"])18print("answer:", answer["answer"])19print("cited product:", products.at[cited, "name"])20print(f"the cited product's text says {claim}:", "yes" if claim in products.at[cited, "description"] else "no")21print("the judges' label:", LABELS[judged[cited]])22# grade 2 is exact; a product nobody judged has no grade, so it counts as 023print("exact products in this answer's context:", sum(judged.get(p, 0) == 2 for p in answer["context_ids"]))2425retrieved = answers.drop("random", level="context") # every citation from the two retrievers' contexts26# LABELS names each grade; a product with no grade counts as unjudged27labels = Counter(LABELS.get(judgments[query_id].get(p), "unjudged")28 for (query_id, _), cited_ids in retrieved["cited"].items() for p in cited_ids)29print("cited products, semantic and bm25 contexts:", sum(labels.values()))30for label in ["exact", "partial", "irrelevant", "unjudged"]:31 print(f"cited products, {label}:", labels[label])
python faithful-but-partial.pyquery: medium size chandelier
answer: I recommend the sybil 12 - light unique / statement classic / traditional chandelier with antler accents (ID: 8171), as it is specifically described as a perfect medium-sized lighting fixture.
cited product: sybil 12 - light unique / statement classic / traditional chandelier with antler accents
the cited product's text says medium-sized: yes
the judges' label: partial
exact products in this answer's context: 2
cited products, semantic and bm25 contexts: 153
cited products, exact: 112
cited products, partial: 40
cited products, irrelevant: 0
cited products, unjudged: 1
La respuesta recomienda una lámpara de araña, diciendo que "está descrita específicamente como una luminaria de tamaño mediano perfecta". La descripción del producto citado sí dice medium-sized (yes), así que una comprobación de respaldo aprobaría la afirmación. Los jueces de la tienda etiquetaron el producto como partial: según la definición de WANDS, es el tipo de producto correcto, pero le falta un modificador que la persona compradora pidió. Ellos vieron su imagen y su página de producto, que el LLM no vio. Su contexto contenía 2 productos exactos, y la respuesta no recomendó ninguno. En esta respuesta, la cita es fiel, y aun así la recomendación falla.
En las respuestas de ambos recuperadores, los 153 productos citados se reparten así: 112 exactos, 40 parciales, 0 irrelevantes y 1 sin juzgar. Todo producto citado que no es exacto es parcial, salvo los 1 que nadie juzgó: el tipo de producto que pidió la persona compradora, con un modificador incorrecto según la lectura de los jueces.
Regla práctica: Puntúa las respuestas primero con tus juicios, porque dicen si una recomendación encaja. Añade una comprobación de respaldo para las afirmaciones que una respuesta hace sobre cada producto, mediante un modelo NLI o un juez LLM. Calibra ese juez con una muestra humana, como hace el capítulo 4 y como hace ARES: usa un conjunto pequeño de datos anotados por personas para la inferencia asistida por predicciones (PPI, por sus siglas en inglés) y así mitigar los errores de predicción, corrigiendo la estimación del juez con las etiquetas humanas (Saad-Falcon et al., 2024). Para las consultas de las que no tienes juicios, una comprobación de respaldo es todo lo que tienes, así que indícalo cuando la informes.
Mide el contexto y luego la respuesta
Un sistema RAG puede fallar en la recuperación o en la generación, así que mide el contexto además de las respuestas. Ragas, un marco para evaluar RAG, puntúa varias medidas sin respuestas de referencia: qué tan bien la recuperación identifica fragmentos de contexto relevantes y enfocados, la fidelidad, y la relevancia de la respuesta. Su recall de contexto necesita una referencia (Es et al., 2024). Sus medidas de contexto trasladan las métricas del capítulo 3, con un LLM como juez. La precisión de contexto de Ragas es, entre sus medidas de contexto, la que tiene en cuenta el orden, la media de precision@k sobre las posiciones que contienen un fragmento relevante (documentación de Ragas). Su recall de contexto es la proporción de las afirmaciones de una respuesta de referencia que el contexto respalda, y una variante basada en IDs compara los IDs recuperados con los IDs de referencia (documentación de Ragas). Con los juicios en mano, la referencia es el conjunto de productos exactos, y el recall de contexto basado en IDs es recall@k.
context recall@k = (exact products in the top k) / (exact products judged for the query)
context precision@k = mean of precision@i over the positions i ≤ k that hold an exact product
¿Qué medida sigue a las respuestas? Salemi y Zamani encontraron que las etiquetas de relevancia se correlacionan solo débilmente con el rendimiento posterior de un sistema RAG, y en su lugar puntúan cada pasaje recuperado según la respuesta que el LLM da a partir de él (Salemi y Zamani, 2024). La correlación de rangos de Spearman es la correlación entre los rangos de dos medidas en lugar de sus valores: vale 1 cuando ordenan los casos de la misma manera y se acerca a 0 cuando los órdenes no tienen relación, y responde la pregunta para una grabación.
Medimos cada contexto que un recuperador construyó para las respuestas grabadas, uno semántico y uno BM25 por consulta de prueba. Este ejemplo construye a mano el recall de contexto y la precisión de contexto, los compara con lib.metrics.recall_at_k y con las copias en lib.generation, y recorre un contexto:
1"""Builds context precision and context recall by hand and checks each against the library's version, then works2through one context. The point rests on the two "every time" lines and on the precision@5 and context precision3of the worked context."""4from lib import generation5from lib.generation import EXACT6from lib.metrics import precision_at_k, recall_at_k7from lib.recorded import rag_answers8from lib.store import load_queries, qrels91011def context_precision(context, judged, k=5):12 """Ragas's context precision, with the judges as the reference: mean precision@i over exact positions i."""13 # positions count from 1, as ranks do; context[:k] is the top k14 hits = [i for i, p in enumerate(context[:k], start=1) if judged.get(p, 0) == EXACT]15 return sum(precision_at_k(context, judged, i) for i in hits) / len(hits) if hits else 0.0161718def context_recall(context, judged, k=5):19 """Ragas's ID-based context recall: the share of the reference IDs that the context holds."""20 # the reference is every exact product judged for the query, not only those in the top k21 reference = {p for p, grade in judged.items() if grade == EXACT}22 return len(reference & set(context[:k])) / len(reference)232425judgments, queries = qrels("test"), load_queries("test")26answers = rag_answers().query("context != 'random'") # the two retrievers' contexts for each test query27contexts = [(answer.context_ids, judgments[answer.query_id]) for answer in answers.itertuples()]28print("contexts:", len(contexts))29same = {"recall_at_k": all(context_recall(c, j) == recall_at_k(c, j, 5) for c, j in contexts),30 "lib.generation": all(context_precision(c, j) == generation.context_precision(c, j) for c, j in contexts)}31print("context recall equals recall_at_k every time:", "yes" if same["recall_at_k"] else "no")32print("context precision equals lib.generation's every time:", "yes" if same["lib.generation"] else "no")3334# the first row: the semantic context for door jewelry organizer35first = answers.iloc[0] # one context, worked through36context, judged = first["context_ids"], judgments[first["query_id"]]37print(f"grades in order, {queries.at[first['query_id'], 'query']}, {first['context']}:", *[judged.get(p, 0) for p in context])38print(f"context precision@5: {context_precision(context, judged):.3f}")39print(f"precision@5: {precision_at_k(context, judged, 5):.3f}")40# exact products judged for each test query, sorted from the fewest to the most41exact = sorted(sum(grade == EXACT for grade in grades.values()) for grades in judgments.values())42print(f"exact products judged per test query: {exact[0]} to {exact[-1]}")43print(f"highest recall@5 possible for the query with the most: {5 / exact[-1]:.3f}")
python context-measures-by-hand.pycontexts: 60
context recall equals recall_at_k every time: yes
context precision equals lib.generation's every time: yes
grades in order, door jewelry organizer, semantic: 1 1 2 2 2
context precision@5: 0.478
precision@5: 0.600
exact products judged per test query: 4 to 170
highest recall@5 possible for the query with the most: 0.029
Sobre los 60 contextos, el recall de contexto equivale a recall_at_k en todos los casos (yes), y la precisión de contexto equivale a la de lib.generation (yes).
Para el contexto semántico de door jewelry organizer, las calificaciones en orden son 1 1 2 2 2, donde 2 es exacto y 1 parcial. Eso da una precision@5 de 0.600 y una precisión de contexto de 0.478, más baja porque los productos exactos quedan al final.
Correlacionar cada medida con la proporción exacta de la respuesta responde esa pregunta. Este ejemplo calcula la correlación de Spearman como la correlación de Pearson de los rangos y la compara con spearmanr de SciPy:
1"""Correlates three context measures with the exact share of each recorded answer, computing Spearman's correlation2by hand and checking it against SciPy. The point rests on the three Spearman lines and the weakest-measure line."""3import pandas as pd4from scipy import stats56from lib.generation import context_precision, context_recall, exact_share7from lib.metrics import precision_at_k8from lib.recorded import rag_answers9from lib.store import qrels1011judgments = qrels("test")12answers = rag_answers().query("context != 'random'") # the two retrievers' contexts for each test query13rows = pd.DataFrame([{"recall@5": context_recall(a.context_ids, judgments[a.query_id]),14 "precision@5": precision_at_k(a.context_ids, judgments[a.query_id], 5),15 "context precision@5": context_precision(a.context_ids, judgments[a.query_id]),16 "exact share": exact_share(a.cited, judgments[a.query_id])} for a in answers.itertuples()])17print("contexts:", len(rows))1819ranks, spearman = rows.rank(), {} # Spearman: Pearson's correlation of the ranks20for measure in ["recall@5", "precision@5", "context precision@5"]:21 spearman[measure] = ranks[measure].corr(ranks["exact share"])22 print(f"spearman with the exact share, {measure}: {spearman[measure]:.3f}")23# rounded to nine places, so floating-point differences in the last digits don't count24matches = all(round(value, 9) == round(stats.spearmanr(rows[measure], rows["exact share"]).statistic, 9)25 for measure, value in spearman.items())26print("matches scipy's spearmanr:", "yes" if matches else "no")27print("weakest with the exact share:", min(spearman, key=spearman.get))
python context-measures-against-answers.pycontexts: 60
spearman with the exact share, recall@5: 0.540
spearman with the exact share, precision@5: 0.797
spearman with the exact share, context precision@5: 0.808
matches scipy's spearmanr: yes
weakest with the exact share: recall@5
El Spearman calculado a mano coincide con el de SciPy (yes).
La correlación más débil con la proporción exacta corresponde a recall@5, con 0.540, frente a 0.797 para precision@5 y 0.808 para la precisión de contexto.
El denominador del recall@5 explica por qué. Las consultas de prueba tienen 4 to 170 productos exactos juzgados, así que el recall@5 más alto que un contexto de cinco productos puede alcanzar para la consulta con más es 0.029. Una respuesta necesita solo tres recomendaciones, sin importar cuántas se hayan juzgado. La precision@5 cuenta cuántos de los cinco encajan, y la precisión de contexto además premia colocarlos primero.
Lee estas correlaciones como una descripción de una sola grabación, no como una prueba. Ambos lados usan los mismos juicios, y una respuesta solo puede citar lo que contiene su contexto, así que cierta correlación viene incorporada. Además, los contextos llegan en pares, semántico y BM25, de las mismas consultas.
Regla práctica: Para un contexto de tamaño fijo, informa la precision@k o la precisión de contexto de tu contexto a partir de tus juicios, junto con el recall@k. Usa el recall cuando una respuesta deba cubrir cada elemento relevante, como cada pieza que encaja en un mismo electrodoméstico. Sin juicios, las versiones juzgadas por LLM de Ragas estiman cantidades similares; calíbralas con una muestra humana antes de confiar en ellas. Elige k midiendo las respuestas sobre consultas de entrenamiento con varios valores de k, lo que requiere respuestas grabadas para esas consultas.
Elige la unidad recuperable
Una unidad recuperable es el fragmento de texto que la recuperación puntúa y devuelve, y que un contexto contiene: un documento entero, un pasaje o una oración. Un documento largo se corta en fragmentos, y la fragmentación es la regla que lo corta, por ejemplo en un número fijo de tokens, en oraciones, en párrafos o en pausas elegidas según el significado. Chen et al. llaman a la unidad de recuperación una decisión de diseño a menudo pasada por alto, y en su estudio indexar proposiciones, enunciados breves y autocontenidos, supera a indexar pasajes (Chen et al., 2023). Más allá de eso, los estudios no coinciden. Uno encuentra que el mejor tamaño depende de las preguntas y del modelo de embeddings: de 64 a 128 tokens para conjuntos de datos con respuestas concisas y basadas en hechos, y de 512 a 1,024 tokens para preguntas que necesitan un contexto más amplio (Bhat et al., 2025). Otro encuentra que los costos computacionales de la fragmentación semántica no se justifican por mejoras consistentes en el rendimiento (Qu et al., 2024). Una comparación de 36 métodos ordena la fragmentación por grupos de párrafos en primer lugar, y encuentra que los fragmentos simples de tamaño fijo en caracteres tuvieron un mal desempeño como referencia (Shaukat et al., 2026).
Una unidad pequeña también puede perder de qué trata. La publicación de ingeniería de un proveedor informa que añadir contexto específico de cada fragmento antes de generar su embedding redujo en un 35% la tasa de fallos de recuperación de los 20 fragmentos principales. Esa es la afirmación del proveedor sobre su propio método (Anthropic, 2024).
Los productos de la tienda son breves, en parte porque el ejemplo del libro recorta cada descripción a unos 400 caracteres (ficha de datos). De las descripciones, 5,933 terminan en ese corte, y 1,568 productos no tienen ninguna.
Las descripciones no vacías tienen una mediana de 68 palabras, y el texto completo que lee la búsqueda llega a lo sumo a 140 palabras por producto. Las páginas completas de productos de la tienda serían más largas.
Aun así, cada producto es un texto breve sobre una sola cosa, así que cortarlo en fragmentos no es la pregunta de la tienda. Su pregunta es qué parte de cada producto indexar. Una oración de una descripción muestra el riesgo: la última oración de la descripción de la lámpara de araña, tomada de la comprobación de soporte, dice the antler 's durability and beauty will last a lifetime ., que nunca indica qué es el producto.
Los embeddings registrados cubren el texto completo de cada producto, así que probamos las unidades solo con BM25, sobre las 50 consultas de entrenamiento, porque elegir una unidad es ajustar. Indexamos cinco unidades: el producto completo (el texto que indexa lib.lexical), solo el nombre, solo la descripción, cada una de las 35,061 oraciones de la descripción por separado, y cada oración con el nombre, la clase y la categoría del producto delante, una forma sencilla de añadir contexto a cada fragmento. La última oración de una descripción cortada es un fragmento incompleto. Las oraciones con los demás campos conservan todos los campos que tiene el producto completo, y un producto sin descripción recibe una unidad con esos campos, igual que su texto completo, de modo que las dos unidades solo se diferencian en el corte de la descripción. UnitSearch en lib.generation ordena cada producto según su unidad de mayor puntuación, así que cada ejecución sigue listando productos. Informamos la precision@5 y la recall@5 que tendría un contexto de cinco productos, con judged@5, la proporción de los 5 primeros que tiene un juicio. UnitSearch ordena las puntuaciones iguales por product_id, así que el código también invierte esa regla y cuenta las consultas de entrenamiento cuyos 5 primeros cambian:
1"""Compares five ways of cutting products into retrievable units under BM25 on the train queries, by precision@5,2recall@5 and judged@5, and counts how often ties change the top 5. The point rests on the precision@5 and3recall@5 lines for the whole product and for the sentences with the other fields."""4import numpy as np56from lib.generation import UnitSearch, sentences7from lib.metrics import judged_at_k, precision_at_k, recall_at_k8from lib.store import load_products, load_queries, product_text, qrels910products = load_products()11# words per description, counted by whitespace12lengths = products["description"].str.split().str.len()13print(f"products with no description: {(lengths == 0).sum():,}")14# the book's sample ends a description it cut with ' ...'15print(f"descriptions the sample cut short: {products['description'].str.endswith(' ...').sum():,}")16# empty descriptions are left out of the median17print(f"description words, median of the others: {lengths[lengths > 0].median():.0f}")18print(f"product text words per product, most: {product_text(products).str.split().str.len().max()}")1920header = products["name"] + ". " + products["product_class"] + ". " + products["category"] + ". " # the other fields21# a product with no description keeps one empty piece, so it still gets a unit22pieces = [(p, piece) for p, text in products["description"].items() for piece in sentences(text) or [""]]23# the empty placeholders for products with no description don't count24print(f"description sentences: {sum(piece != '' for _, piece in pieces):,}")25# 8171 is the chandelier from the support check26print("last sentence of product 8171:", sentences(products.at[8171, "description"])[-1])27units = { # unit name: (texts to index, the product each belongs to)28 "whole product": (product_text(products), products.index),29 "name only": (products["name"], products.index),30 "description only": (products["description"], products.index),31 "sentences": ([piece for _, piece in pieces], [p for p, _ in pieces]),32 "sentences with the other fields": ([header[p] + piece for p, piece in pieces], [p for p, _ in pieces]),33}34train, judgments = load_queries("train"), qrels("train") # choosing a unit is tuning: train queries only35scores = {}36for name, (texts, owners) in units.items():37 run = UnitSearch(list(texts), list(owners)).run(train, k=5) # equal scores by product_id38 for metric in [precision_at_k, recall_at_k, judged_at_k]:39 scores[name, metric] = np.mean([metric(run[q], judgments[q], 5) for q in train.index])40 print(f"{name}, train {metric.__name__.replace('_at_k', '')}@5: {scores[name, metric]:.3f}")41 flipped = UnitSearch(list(texts), [-p for p in owners]).run(train, k=5) # negated owners: ties go to the highest ID42 changed = sum(set(run[q]) != {-p for p in flipped[q]} for q in train.index)43 print(f"{name}, train queries whose top 5 changes with ties reversed: {changed}")44print("highest train precision@5:", max(units, key=lambda name: scores[name, precision_at_k]))45for metric in [precision_at_k, recall_at_k]:46 gap = scores["whole product", metric] - scores["sentences with the other fields", metric]47 print(f"whole product minus sentences with the other fields, train {metric.__name__.replace('_at_k', '')}@5: {gap:.3f}")
python retrievable-unit-on-train.pyproducts with no description: 1,568
descriptions the sample cut short: 5,933
description words, median of the others: 68
product text words per product, most: 140
description sentences: 35,061
last sentence of product 8171: the antler 's durability and beauty will last a lifetime .
whole product, train precision@5: 0.464
whole product, train recall@5: 0.124
whole product, train judged@5: 0.940
whole product, train queries whose top 5 changes with ties reversed: 4
name only, train precision@5: 0.368
name only, train recall@5: 0.091
name only, train judged@5: 0.960
name only, train queries whose top 5 changes with ties reversed: 28
description only, train precision@5: 0.304
description only, train recall@5: 0.049
description only, train judged@5: 0.828
description only, train queries whose top 5 changes with ties reversed: 4
sentences, train precision@5: 0.272
sentences, train recall@5: 0.034
sentences, train judged@5: 0.732
sentences, train queries whose top 5 changes with ties reversed: 18
sentences with the other fields, train precision@5: 0.428
sentences with the other fields, train recall@5: 0.106
sentences with the other fields, train judged@5: 0.944
sentences with the other fields, train queries whose top 5 changes with ties reversed: 8
highest train precision@5: whole product
whole product minus sentences with the other fields, train precision@5: 0.036
whole product minus sentences with the other fields, train recall@5: 0.018
| Unidad | precision@5 | recall@5 | judged@5 | Los 5 primeros cambian con los empates invertidos |
|---|---|---|---|---|
| Producto completo | 0.464 | 0.124 | 0.940 | 4 |
| Solo nombre | 0.368 | 0.091 | 0.960 | 28 |
| Solo descripción | 0.304 | 0.049 | 0.828 | 4 |
| Oraciones | 0.272 | 0.034 | 0.732 | 18 |
| Oraciones con los demás campos | 0.428 | 0.106 | 0.944 | 8 |
La mayor precision@5 en entrenamiento corresponde a whole product. La comparación justa es con las oraciones que llevan los demás campos: los mismos campos, los mismos productos al alcance, y un judged@5 de 0.944 frente a 0.940 del producto completo.
Cortar la descripción en oraciones cuesta 0.036 en la precision@5 de entrenamiento y 0.018 en la recall@5. Los empates deciden parte de esas diferencias: cuando varios productos empatan en el quinto puesto, la regla de desempate elige cuáles llegan al contexto, y al invertirla cambian los 5 primeros en 8 consultas de entrenamiento con las oraciones con los demás campos y en 4 con el producto completo. Lee una diferencia de este tamaño como aproximada.
Las demás unidades también pierden campos. La descripción sola nunca puede devolver los productos que no tienen descripción, y las oraciones sueltas hacen aparecer muchos productos que nadie juzgó, así que su precisión es en parte una suposición. Estos son números de entrenamiento y no probados: orientan una elección, pero no demuestran nada.
Regla práctica: Cuando tus elementos son cortos, indexa cada elemento completo como una unidad, como hace la tienda. Cuando son largos, fragméntalos, pon el título del elemento delante de cada fragmento y elige el tamaño del fragmento con las consultas de entrenamiento según las medidas de contexto de la sección anterior. Pásale al LLM el elemento completo, o el fragmento con su título, para que sepa lo que está leyendo. Antes de fiarte de una diferencia pequeña, cuenta las consultas cuyo top k cambia cuando los empates se resuelven al revés.
Lee las búsquedas de un agente en su traza
A diferencia de las respuestas grabadas, un agente busca por sí mismo: es un LLM que se ejecuta en un bucle y actúa. Una herramienta es una función que el programa ofrece al modelo, descrita por un nombre, una descripción y sus parámetros. Una llamada a herramienta es la solicitud del modelo para ejecutar una herramienta con argumentos. En el bucle del agente, el programa ejecuta cada llamada a herramienta, devuelve el resultado y el modelo decide qué hacer a continuación. En Ollama, que ejecutó el modelo de la tienda, un bucle de agente permite que el modelo decida cuándo invocar herramientas e incorporar sus resultados en sus respuestas (documentación de Ollama). recordings/agent_trace.py es un bucle de ese tipo. Los agentes ReAct intercalan trazas de razonamiento con acciones específicas de la tarea. En tareas de respuesta a preguntas (HotpotQA) y de verificación de hechos (Fever), con una API de Wikipedia como herramienta, superan la alucinación y la propagación de errores que son comunes en el razonamiento de cadena de pensamiento (Yao et al., 2023). La traza es el registro de cada llamada a herramienta y de su resultado.
Las búsquedas de un agente son consultas, y no tienen por qué parecerse a las de un comprador. En un registro de 14 millones de solicitudes de búsqueda de agentes, más del 90 % de las sesiones de varios turnos contienen como máximo diez pasos, y en promedio el 54 % de los términos de consulta que añade una búsqueda ya aparecen en la evidencia acumulada (Ning et al., 2026). El agente recoge palabras de lo que ha leído.
La grabación dio al agente cada consulta de prueba como la petición del comprador, con una herramienta, search, descrita como "Search the store's catalog. Returns the top 5 products: ID, name, class and attributes.". Puede buscar hasta 3 veces, con cualquier redacción, y luego responder con tres identificadores de producto. La herramienta no devuelve ninguna descripción.
La grabación se ejecutó dos veces, con el mismo modelo y el mismo prompt: una con BM25 detrás de la herramienta, y otra con recuperación semántica, que incrustaba el texto de búsqueda del agente con el mismo modelo de embeddings que los productos. Las trazas almacenan los resultados de cada búsqueda BM25 en el orden de empate propio de bm25s, como lo hacen los contextos de las respuestas, así que 7 de las 32 búsquedas BM25 obtienen resultados que difieren de los que devuelve lib.lexical, 6 de ellas solo en el orden. Esto es lo que el agente buscó realmente:
1"""Reads the recorded agent traces for both tools: each agent's first search, how many searches each tool took, and2whether BM25's stored results match lib.lexical. The point rests on the first-search lines and the one-search3trace counts."""4from lib.lexical import LexicalSearch5from lib.recorded import agent_traces, manifest, rag_answers6from lib.store import load_products, load_queries78recording, queries = manifest("agent-trace"), load_queries("test")9print("tool description:", recording["prompts"]["tool"]["function"]["description"])10print("searches allowed:", recording["max_searches"])11traces = {(t["retriever"], t["query_id"]): t for t in agent_traces()}12print("traces:", len(traces))13# index 0 is the agent's first search14first = {key: t["searches"][0]["query"] for key, t in traces.items()}15print("first searches the same under both tools:", sum(first[("bm25", q)] == first[("semantic", q)] for q in queries.index))16print("first searches that keep the query as typed:", sum(first[("bm25", q)] == queries.at[q, "query"] for q in queries.index))17for q in queries.index:18 if first[("bm25", q)] != queries.at[q, "query"]:19 print(f"first search for {queries.at[q, 'query']}: {first[('bm25', q)]}")20# the five products each recorded answer read, keyed by context (semantic, bm25 or random) and query21context = {(a.context, a.query_id): a.context_ids for a in rag_answers().itertuples()}22print("traces whose first search returns the answer recording's context:",23 # lists compared with ==: the same five products, in the same order24 sum(t["searches"][0]["results"] == context[key] for key, t in traces.items()))25for tool in ["bm25", "semantic"]:26 mine = [t for (retriever, _), t in traces.items() if retriever == tool]27 print(f"{tool}, searches: {sum(len(t['searches']) for t in mine)}")28 print(f"{tool}, traces with one search: {sum(len(t['searches']) == 1 for t in mine)}")2930# `shown` is how many products the search tool returns per search (its top 5)31lexical, shown = LexicalSearch(load_products()), recording["results_shown"]32stored = [s for (tool, _), t in traces.items() if tool == "bm25" for s in t["searches"]] # what the agent saw33rerun = [lexical.search(s["query"], shown).index.tolist() for s in stored] # ties by product_id34differ = [(s["results"], r) for s, r in zip(stored, rerun) if s["results"] != r]35print("bm25 searches whose results differ from lib.lexical:", len(differ))36# the same products in another order: a tie-break, not a different result37print("bm25 searches whose results differ from lib.lexical only in order:", sum(set(a) == set(b) for a, b in differ))
python agent-searches-in-traces.pytool description: Search the store's catalog. Returns the top 5 products: ID, name, class and attributes.
searches allowed: 3
traces: 60
first searches the same under both tools: 30
first searches that keep the query as typed: 26
first search for 48" sliding single track , barn door for laundry: 48" sliding single track barn door laundry
first search for counter top one cup hot water dispenser: counter top hot water dispenser one cup
first search for refrigerator with ice an water in door: refrigerator with ice and water in door
first search for tye dye duvet cover: tie dye duvet cover
traces whose first search returns the answer recording's context: 55
bm25, searches: 32
bm25, traces with one search: 29
semantic, searches: 35
semantic, traces with one search: 27
bm25 searches whose results differ from lib.lexical: 7
bm25 searches whose results differ from lib.lexical only in order: 6
La primera búsqueda es la misma con ambas herramientas en 30 consultas, como cabría esperar: el agente la escribe antes de que la herramienta haya devuelto nada, a partir del mismo prompt y la misma descripción de herramienta, con temperatura 0. Mantiene la consulta tal como se escribió en 26 casos.
De las demás, una corrige una errata: tye dye duvet cover se convierte en tie dye duvet cover. Otra corrige un error de palabra real que el corrector del capítulo 8 no detecta: an se convierte en and en refrigerator with ice and water in door. Tanto an como and son palabras vacías para BM25 (capítulo 5), así que solo la recuperación semántica percibe ese cambio. Las otras dos se convierten en 48" sliding single track barn door laundry y counter top hot water dispenser one cup.
En 55 de las 60 trazas, la primera búsqueda devuelve exactamente los cinco productos que la respuesta grabada puso en su contexto.
El agente rara vez vuelve a buscar. Con BM25 realiza 32 búsquedas en total, y 29 trazas se detienen tras una. Con recuperación semántica realiza 35, y 27 se detienen tras una.
¿De dónde salen las palabras de una búsqueda posterior? Para averiguarlo, compara cada búsqueda posterior con las palabras ya usadas en las búsquedas, y con los nombres, clases y atributos que la herramienta había mostrado:
1"""Counts the words each later search adds to the agent's query so far, and how many of those the tool had already2shown. The point rests on the "words the tool had shown" line for each tool."""3from lib.generation import shown, words4from lib.recorded import agent_traces5from lib.store import load_products, load_queries67products, queries = load_products(), load_queries("test")8for tool in ["bm25", "semantic"]:9 later = new = from_results = 010 for trace in (t for t in agent_traces() if t["retriever"] == tool):11 # words are lowercase runs of letters and digits, so case and punctuation don't count12 asked, seen = words(queries.at[trace["query_id"], "query"]), set()13 for number, search in enumerate(trace["searches"]):14 if number > 0: # a later search: the words it adds, and where from15 added = words(search["query"]) - asked16 later, new, from_results = later + 1, new + len(added), from_results + len(added & seen)17 # every word the agent has searched so far18 asked |= words(search["query"])19 # what the tool showed for that search: name, class and attributes, but no description20 seen |= words(shown(search["results"], products))21 print(f"{tool}, later searches: {later}")22 print(f"{tool}, words that later searches add: {new}")23 print(f"{tool}, of those, words the tool had shown: {from_results}")
python agent-later-searches.pybm25, later searches: 2
bm25, words that later searches add: 2
bm25, of those, words the tool had shown: 1
semantic, later searches: 5
semantic, words that later searches add: 4
semantic, of those, words the tool had shown: 4
Las búsquedas posteriores aportan pocas palabras propias. Con BM25, 2 búsquedas posteriores añaden 2 palabras, de las cuales 1 las había mostrado antes la herramienta. Con recuperación semántica, 5 búsquedas posteriores añaden 4 palabras, de las cuales 4 se habían mostrado antes. Cifras tan pequeñas describen estas trazas; no son una tasa que deba compararse con la de Ning et al.
Regla práctica: Lee las trazas antes de evaluar a un agente. Cuenta sus búsquedas por tarea, compara cada búsqueda con las palabras del comprador y averigua de dónde proceden las palabras añadidas. Incorpora las búsquedas del agente a las consultas con las que pruebas tu recuperador, evaluadas con los juicios para la petición del comprador o juzgadas de nuevo, porque un recuperador ajustado con consultas de personas no ha sido probado con las de un agente. Espera que un agente que en su mayoría transmite las palabras del comprador esté limitado por la misma recuperación que una respuesta RAG.
Compara los recuperadores detrás de la herramienta del agente
Un agente que puede volver a buscar podría parecer que hace que el recuperador importe menos. Un benchmark midió lo contrario. BrowseComp-Plus fija la colección que los agentes buscan, de modo que se puedan intercambiar los recuperadores dentro de un mismo agente. Con BM25, GPT-5 alcanza el 55.9 %, y con el recuperador Qwen3-Embedding-8B llega al 70.1 %, haciendo en promedio menos llamadas de búsqueda, 21.74 frente a 23.23 (Chen et al., 2025, Tabla 1). Las compras son una tarea clásica para los agentes. WebShop contiene 1.18 millones de productos reales, y su mejor modelo, en 2022, alcanzó una tasa de éxito en las tareas del 29 %, frente al 59 % de los expertos humanos (Yao et al., 2022). En WebMall, cuatro tiendas simuladas, sus autores informan de que los mejores agentes completan las tareas en tasas inferiores al 65 %, en búsquedas del producto más barato y de productos descritos de forma vaga (Peeters et al., 2025).
Un agente al que se le pide elegir entre los resultados de su búsqueda debe elegir solo lo que esos resultados devuelven, y su traza muestra si lo hizo. Sus elecciones quedan entonces acotadas por la recuperación, igual que una respuesta RAG.
El agente registrado de la tienda busca en el catálogo hasta 3 veces con una sola herramienta, y después elige tres productos. Puntuar esas elecciones con cada herramienta, mediante precisión@3, es la segunda de las comparaciones planificadas del capítulo, y queda establecida si su valor p de permutación está por debajo de 0.025. La precisión@3 son las elecciones exactas divididas entre 3, de modo que una elección que falta cuenta como fallo. Primero, cuenta dónde se perdieron las elecciones, para cada herramienta: elecciones que la herramienta nunca devolvió, elecciones que nadie juzgó, trazas con menos de tres elecciones, trazas cuyas búsquedas no devolvieron ningún producto exacto, y trazas que vieron un producto exacto y no eligieron ninguno. Después compara las elecciones con el top 3 de la herramienta en la primera búsqueda, una comprobación exploratoria:
1"""Scores each tool's agent picks with precision@3 and counts how the traces went, with an exploratory check2against the tool's first search. The point rests on the precision@3 lines and the picks-the-tool-never-returned3counts."""4import pandas as pd56from lib.generation import EXACT, report_planned7from lib.metrics import precision_at_k8from lib.recorded import agent_traces9from lib.significance import compare10from lib.store import qrels1112judgments, picks, top_three, below = qrels("test"), {}, {}, 013for tool in ["bm25", "semantic"]:14 traces = [t for t in agent_traces() if t["retriever"] == tool]15 # every product any of the agent's searches returned16 returned = [{p for search in t["searches"] for p in search["results"]} for t in traces]17 # exact products each trace's searches returned; a product nobody judged counts as not exact18 seen = [sum(judgments[t["query_id"]].get(p, 0) == EXACT for p in r) for t, r in zip(traces, returned)]19 picked = [sum(judgments[t["query_id"]].get(p, 0) == EXACT for p in t["picked"]) for t in traces]20 print(f"{tool}, picks the tool never returned: {sum(len(set(t['picked']) - r) for t, r in zip(traces, returned))}")21 print(f"{tool}, picks nobody judged: {sum(p not in judgments[t['query_id']] for t in traces for p in t['picked'])}")22 print(f"{tool}, traces with fewer than three picks: {sum(len(t['picked']) < 3 for t in traces)}")23 print(f"{tool}, traces whose searches returned no exact product: {sum(s == 0 for s in seen)}")24 print(f"{tool}, traces that saw an exact product and picked none: {sum(s > 0 and k == 0 for s, k in zip(seen, picked))}")25 # precision_at_k divides by 3, so a trace with fewer picks scores lower26 picks[tool] = pd.Series({t["query_id"]: precision_at_k(t["picked"], judgments[t["query_id"]], 3) for t in traces})27 # index 0 is the agent's first search28 top_three[tool] = pd.Series({t["query_id"]: precision_at_k(t["searches"][0]["results"], judgments[t["query_id"]], 3)29 for t in traces}) # the tool's own top 3 for the first search30 print(f"{tool}, precision@3 of the picks: {picks[tool].mean():.3f}")31 print(f"{tool}, precision@3 of the first search's top 3: {top_three[tool].mean():.3f}")32 p_value = compare(picks[tool], top_three[tool])["permutation p"]33 print(f"{tool}, picks against the top 3, exploratory permutation p: {p_value:.3f}")34 # uncorrected: this check is exploratory, not one of the planned comparisons35 below += p_value < 0.053637print(f"picks against the top 3, p-values below 0.05 uncorrected: {below} of 2")38report_planned("agent picks, semantic over bm25", picks["semantic"], picks["bm25"])
python agent-picks-by-tool.pybm25, picks the tool never returned: 0
bm25, picks nobody judged: 3
bm25, traces with fewer than three picks: 2
bm25, traces whose searches returned no exact product: 5
bm25, traces that saw an exact product and picked none: 6
bm25, precision@3 of the picks: 0.567
bm25, precision@3 of the first search's top 3: 0.500
bm25, picks against the top 3, exploratory permutation p: 0.152
semantic, picks the tool never returned: 0
semantic, picks nobody judged: 0
semantic, traces with fewer than three picks: 0
semantic, traces whose searches returned no exact product: 5
semantic, traces that saw an exact product and picked none: 2
semantic, precision@3 of the picks: 0.622
semantic, precision@3 of the first search's top 3: 0.633
semantic, picks against the top 3, exploratory permutation p: 1.000
picks against the top 3, p-values below 0.05 uncorrected: 0 of 2
agent picks, semantic over bm25, mean difference: 0.056
agent picks, semantic over bm25, wins, losses, ties: 5, 4, 21
agent picks, semantic over bm25, permutation p: 0.422
agent picks, semantic over bm25, established at 0.025: no
agent picks, semantic over bm25, t-test p: 0.305
agent picks, semantic over bm25, t-test agrees: yes
agent picks, semantic over bm25, 97.5% interval: -0.033 to 0.209
agent picks, semantic over bm25, interval agrees: yes
Las dos herramientas no muestran una diferencia establecida en sus elecciones. La precisión@3 es 0.622 con recuperación semántica y 0.567 con BM25, y el valor p de permutación de la diferencia es 0.422 (ambas comparaciones). Con este modelo, este prompt y estas consultas de prueba, eso no es evidencia de que el recuperador no importe, solo de que estas consultas no muestran una diferencia.
Contados de la misma forma para cada herramienta, los fallos son de estos tipos. Las elecciones que la herramienta nunca devolvió suman 0 con BM25 y 0 con recuperación semántica, así que la cota se cumple. La recuperación también limita las elecciones: en 5 trazas con BM25 y 5 con recuperación semántica, ninguna búsqueda devolvió un producto exacto, así que ninguna elección podía ser exacta.
Los otros fallos están en las propias elecciones. Con BM25 el agente vio un producto exacto y no eligió ninguno en 6 trazas, frente a 2 con recuperación semántica; 3 de sus elecciones no están juzgadas, frente a 0; y 2 trazas tienen menos de tres elecciones, frente a 0. Tanto las elecciones no juzgadas como las que faltan cuentan como fallos.
Las elecciones del agente se leen igual con cada herramienta. El top 3 propio de la herramienta en la primera búsqueda obtiene 0.500 con BM25 y 0.633 con recuperación semántica. Las elecciones medidas frente a ese top 3 obtienen valores p de permutación de 0.152 con BM25 y 1.000 con recuperación semántica, y 0 of 2 quedan por debajo de 0.05 sin corregir. Elegimos la comprobación después de ver los resultados de las pruebas, así que nunca queda establecida.
Regla práctica: Prueba el recuperador detrás de la herramienta de un agente como lo probarías para personas, con las búsquedas propias del agente y sus elecciones finales, puntuadas con juicios humanos. Comprueba que cada elección proviene de un resultado de la herramienta. Cuenta las tareas en las que la herramienta nunca devolvió un producto relevante, porque ningún agente puede corregir eso y solo la recuperación puede hacerlo.
Qué sale mal en producción
Un asistente en vivo responde a cada cliente con una llamada nueva al modelo, sobre un contexto que la recuperación construye para esa solicitud.
El modelo, el prompt y el contexto forman un solo sistema. Una versión distinta del modelo, un prompt reformulado, otro tamaño de contexto o un orden diferente de productos pueden cambiar cada respuesta. Los manifiestos de la tienda fijan el digest del modelo, los prompts, los esquemas de las respuestas y de las herramientas, y la ventana de contexto. Si cambias cualquiera de ellos, vuelve a puntuar las respuestas, con los mismos juicios y el mínimo aleatorio. Conserva las respuestas en bruto y cada contexto, como hacen las grabaciones.
La verificación de citas forma parte del camino de la respuesta. La comprobación de IDs es barata, así que ejecútala en cada respuesta antes de que el cliente la vea, y registra cada fallo junto con la respuesta y su contexto.
Las abstenciones se mueven con la recuperación. Sigue la proporción de respuestas que no recomiendan nada. En los contextos aleatorios de la tienda, 29 de las 30 respuestas no recomiendan nada, así que un aumento de esa proporción puede significar que cambiaron la recuperación o el catálogo. Lee esas respuestas antes de suponer que cambió el modelo.
El texto de los productos llega al prompt. Las descripciones de producto pueden venir de fuera de tu equipo, y el LLM las lee como parte de su entrada. El capítulo 4 cita un estudio en el que palabras e instrucciones insertadas en un texto engañaron a jueces LLM. Prueba el asistente con productos cuyo texto contenga instrucciones antes de confiarle un catálogo que tú no escribes.
Los contextos más largos cambian la respuesta. Subir k alarga el contexto y añade más distractores, y ambos pueden perjudicar (Liu et al., 2024; Jin et al., 2024). Mide las respuestas con cada ajuste con las consultas de train.
El tráfico de agentes es una carga de trabajo distinta. En los registros que estudiaron Ning et al., los agentes envían muchas consultas generadas por máquina por tarea, mientras que el agente de la tienda envió sobre todo una. Un estudio advierte que, con tráfico de agentes, la caché puede perder eficacia y el preprocesamiento de consultas puede añadir sobrecarga sin mejorar los resultados (Pezzuti et al., 2026). Registra las búsquedas de los agentes por separado de las de las personas, y prueba el recuperador con ambas.
Regla práctica: Versiona el modelo, el prompt y los ajustes de contexto junto con las respuestas, verifica las citas en cada respuesta, sigue las abstenciones y conserva las búsquedas de los agentes en un conjunto de prueba propio.
Decisiones que tomó este capítulo
Solo una comparación planificada establecida podría haber cambiado el recuperador de la tienda, y la fila Establecida de la tabla indica si cada una lo está.
Las 2 comparaciones planificadas del capítulo, recuperación semántica menos BM25 sobre las consultas de prueba, quedan establecidas por debajo de 0.025:
| Medida | Respuestas, proporción media exacta | Elecciones del agente, precisión@3 |
|---|---|---|
| Semántica | 0.658 | 0.622 |
| BM25 | 0.639 | 0.567 |
| Diferencia media | 0.019 | 0.056 |
| Victorias / derrotas / empates | 4, 5, 21 | 5, 4, 21 |
| Permutación p | 0.765 | 0.422 |
| Establecida | no | no |
| t-test p | 0.715 | 0.305 |
| Intervalo del 97.5% | -0.078 to 0.161 | -0.033 to 0.209 |
| El t-test coincide | yes | yes |
| El intervalo coincide | yes | yes |
- El contexto: cinco productos completos de la recuperación semántica, el clasificador que hay que superar. Cinco es el ajuste fijo y no probado de la grabación. Las respuestas no muestran una diferencia establecida entre la recuperación semántica y BM25, así que el recuperador se apoya en la ventaja establecida del capítulo 3 en nDCG@10.
- Respuestas calificadas con notas humanas: la proporción exacta de lo que cita cada respuesta, con las respuestas que no recomiendan nada contadas aparte y un contexto aleatorio como mínimo.
- Citas comprobadas por ID en cada respuesta. La grabación pasa la comprobación y se mantiene. Las comprobaciones de soporte, mediante un modelo NLI o un juez LLM, solo cuentan si se calibran con una muestra humana.
- Contexto medido con precisión@5 y precisión del contexto a partir de los juicios, con recall@5 junto a ellas, porque el recall@5 de un contexto de cinco productos no puede llegar a 1 cuando una consulta tiene más de cinco productos exactos.
- La unidad recuperable: el producto completo. Tiene la mayor precisión@5 de entrenamiento, y dividir las descripciones en oraciones, aun con los demás campos delante, cuesta 0.036.
- Herramienta del agente: los mismos recuperadores, probados sobre las búsquedas y elecciones del agente. Las elecciones no muestran una diferencia establecida entre las herramientas, y cada elección procedió de lo que devolvió la herramienta.
- Alcance: un modelo, dos prompts, las consultas de prueba. Todo hallazgo sobre el LLM se refiere a
gemma4:12b-it-q4_K_Mcon los prompts registrados. Un modelo o prompt distinto es un cambio que hay que volver a evaluar, igual que un cambio de recuperador. - Lo que mostró el capítulo: una comprobación de citas demuestra que un producto estaba delante del modelo, no que encaje, y una ganancia de clasificación debe probarse sobre las respuestas que alimenta.
Este capítulo, en esta edición
Edición 2026.11.10Ejemplos verificados el 19 de nov de 2026Superan la prueba 10 de 10 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.10.