Notas prácticas: RAG, Embeddings y bases de datos vectoriales — Explicado desde cero
Guía paso a paso para utilizar las notas prácticas: RAG, Embeddings y bases de datos vectoriales — Explicado desde cero: contratos, verificaciones y espacios para código listo para usar en equipos que implementan este patrón.
Úselo como una versión reestructurada dirigida a operadores de las ideas presentadas en “RAG, Embeddings y bases de datos vectoriales: explicado desde cero”: etapas claras, secciones de código ordenadas y notas de recuperación que perduran tras el traspaso de tareas. La etapa de Resumen funciona mejor si se considera como una superficie medible. Capture una transcripción clave, un caso de fallo y la nota de reversión antes de ampliar el alcance. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el fallo debe apuntar a una sola responsabilidad y no a un proceso complicado.
¿Qué es RAG?
En la fase de “¿Qué es RAG?”, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Trate esta fase como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas. Cite los pasajes que realmente sirvieron de base para la respuesta. Sin citaciones, los operadores no pueden distinguir entre alucinaciones y lagunas en el indexado.
[ Documents ] --> [ Chunk ] --> [ Embed ] --> [ Store in Vector DB ]
|
User Question --> [ Embed Question ] --> [ Find Similar Chunks ] --> [ LLM ] --> Answer
¿Qué es un embedding?
En la etapa de “¿Qué es un Embedding?”, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Registre los tiempos de ejecución y el costo en tokens o consultas junto con los resultados funcionales. La visibilidad temprana del costo evita facturas inesperadas cuando el proceso pasa de entornos de demostración a entornos compartidos. Cite los pasajes que realmente sustentan la respuesta; sin citas, los operadores no pueden distinguir entre alucinaciones y brechas en el indexado.
"king" → [0.21, -0.05, 0.87, ..., 0.33] (384 numbers)
"queen" → [0.19, -0.03, 0.85, ..., 0.31] (384 numbers)
"banana" → [-0.72, 0.44, 0.01, ..., -0.56] (384 numbers)
Cómo el texto se convierte en números
En la etapa de cómo el texto se convierte en números, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de secretos y las banderas de funcionalidad deben encontrarse en un lugar que los operadores puedan auditar sin tener que leer todo el sistema. Cite los pasajes que realmente sustentan la respuesta. Sin citaciones, los operadores no pueden distinguir entre alucinaciones y lagunas en el indexado. En la etapa de cómo el texto se convierte en números, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el error debe apuntar a una única responsabilidad y no a una situación complicada.
Paso 1: Tokenización
Al trabajar en la etapa de tokenización del Paso 1, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Trate esta etapa como un contrato entre las entradas y las salidas validadas. Asigne nombres a los artefactos, defina comprobaciones de éxito y rechace las completaciones parciales silenciosas. Almacene en caché las instrucciones del sistema estables y los esquemas de las herramientas. Reenviar un preámbulo idéntico es una causa común de desperdicio.
"backend engineer jobs in bangalore"
Tokens: ["backend", "engineer", "jobs", "in", "bang", "##alore"]
Paso 2: Capas de Transformer
Al trabajar en la etapa de las capas Transformer del Paso 2, anote primero el contrato: entradas requeridas, señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Registre los tiempos y el costo de tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando se pasa de entornos de demostración a entornos compartidos. Mida el rendimiento en un conjunto fijo de preguntas antes de ajustar los prompts. Cambiar constantemente los prompts rara vez soluciona un sistema de recuperación deficiente.
"backend" → [0.52, -0.18, 0.83, 0.45, ...] (384 numbers)
"engineer" → [0.48, -0.15, 0.79, 0.41, ...] (384 numbers)
"jobs" → [0.31, -0.05, 0.67, 0.22, ...] (384 numbers)
"in" → [0.07, 0.02, 0.11, 0.04, ...] (384 numbers)
"bang" → [0.39, 0.27, 0.55, 0.30, ...] (384 numbers)
"##alore" → [0.14, 0.10, 0.21, 0.11, ...] (384 numbers)
Paso 3: Agrupación
Al trabajar en la etapa de agrupamiento del Paso 3, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de secretos y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin tener que leer todo el sistema. Mida la tasa de recuperación con un conjunto fijo de preguntas antes de ajustar los prompts. El cambio constante de prompts rara vez soluciona un sistema de recuperación deficiente. Al trabajar en la etapa de agrupamiento del Paso 3, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando falla un paso, el fallo debe apuntar a una única responsabilidad y no a un proceso complicado.
Dimension 1: (0.52 + 0.48 + 0.31 + 0.07 + 0.39 + 0.14) / 6 = 0.318
Dimension 2: (-0.18 + -0.15 + -0.05 + 0.02 + 0.27 + 0.10) / 6 = 0.002
... same for all 384 dimensions ...
Final: [0.318, 0.002, ...] ← ONE vector for the entire sentence
Aclaración rápida: Vectores vs dimensiones
La aclaración rápida sobre vectores y dimensiones funciona mejor cuando se trata como una superficie medible. Capture una transcripción ejemplar, un caso de fallo y la nota de reversión antes de ampliar el alcance. Trate esta etapa como un contrato entre las entradas y las salidas validadas. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace completaciones parciales silenciosas. Separe la política de fragmentación de la política de recuperación. Cambiar una no debe obligar a reescribir la otra cuando cambian las métricas de calidad.
2D point (on a map): [x, y] → 1 vector, 2 dimensions
3D point (in a room): [x, y, z] → 1 vector, 3 dimensions
Embedding: [n1, n2, ..n384] → 1 vector, 384 dimensions
¿Qué es una base de datos vectorial?
La etapa “¿Qué es un vector?” funciona mejor cuando se trata como una superficie medible. Capture una transcripción ejemplar, un caso de fallo y la nota de reversión antes de ampliar el alcance. Registre los tiempos y el costo de tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando el proceso pasa de la fase de demostración a entornos compartidos. Separe la política de fragmentación de la política de recuperación; cambiar una no debe obligar a reescribir la otra cuando cambian las métricas de calidad.
┌──────────────────────────────────────────────────┐
│ Vector DB │
│ │
│ Entry 1: │
│ text: "Senior Backend Engineer Wipro..." │
│ vector: [0.21, -0.05, 0.87, ...] │
│ │
│ Entry 2: │
│ text: "Frontend dev needed Chennai..." │
│ vector: [0.71, 0.55, -0.30, ...] │
│ │
│ Entry 3: │
│ text: "Backend Engineer Flipkart..." │
│ vector: [0.19, -0.03, 0.85, ...] │
│ │
└──────────────────────────────────────────────────┘
¿Cuántos vectores se almacenan?
La etapa “¿Cuántos vectores se obtienen?” funciona mejor cuando se trata como una superficie medible. Capture un registro ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos confidenciales y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin tener que leer todo el sistema. Separe la política de particionamiento de la política de recuperación. Cambiar una no debe obligar a reescribir la otra cuando cambian las métricas de calidad. La etapa “¿Cuántos vectores se obtienen?” funciona mejor cuando se trata como una superficie medible. Capture un registro ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Prefiera unidades pequeñas y probables sobre scripts extensos. Cuando falla un paso, el fallo debe apuntar a una única responsabilidad en lugar de a un proceso complicado.
Page 1 (naukri.com) → 3000 chars → split into 6 chunks → 6 vectors
Page 2 (linkedin.com) → 5000 chars → split into 10 chunks → 10 vectors
Page 3 (indeed.com) → 2000 chars → split into 4 chunks → 4 vectors
Page 4 (glassdoor.com) → 4500 chars → split into 9 chunks → 9 vectors
Page 5 (some blog) → 1500 chars → split into 3 chunks → 3 vectors
─────────
32 vectors in the database
Cómo funciona la recuperación
En la fase de “Cómo funciona la recuperación”, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Considere esta fase como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas. Cite los pasajes que realmente sustentan la respuesta. Sin citaciones, los operadores no pueden distinguir entre alucinaciones y brechas en el indexado.
Paso 1: Incorpore la consulta con el MISMO modelo
En el Paso 1, antes de modificar el código, debe definirse la etapa a incrustar, las entradas necesarias, el responsable del paso y los criterios de finalización. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Se deben registrar los tiempos de ejecución y el costo en tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando el proceso pasa de entornos de demostración a entornos compartidos. Se prefieren salidas estructuradas con validación de esquema sobre textos en formato libre cuando el siguiente paso implica código o una llamada a una herramienta.
"backend engineering jobs in Bengaluru" → [0.20, -0.04, 0.86, ...]
Paso 2: Comparar con cada vector almacenado
En la etapa 2 de Comparar contra, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea desde un punto de control conocido sin tener que adivinar el estado oculto. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos confidenciales y las banderas de funcionalidad deben encontrarse en un lugar donde los operadores puedan auditarlos sin necesidad de leer todo el sistema. Cite los pasajes que realmente sustentan la respuesta. Sin citaciones, los operadores no pueden distinguir entre alucinaciones y lagunas en el indexado. En la etapa 2 de Comparar contra, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea desde un punto de control conocido sin tener que adivinar el estado oculto. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando una tarea falla, el error debe indicar una única responsabilidad y no un proceso complejo e entrelazado.
Query vector vs Chunk 1 ("Senior Backend Engineer Wipro, Bengaluru...")
→ similarity: 0.95 ✅
Query vector vs Chunk 2 ("Frontend dev needed Chennai...")
→ similarity: 0.23 ❌Query vector vs Chunk 3 ("Backend Engineer Flipkart Bengaluru...")
→ similarity: 0.97 ✅
Paso 3: Devolver los k bloques principales
Al trabajar en la etapa de Paso 3: Devolver, anote primero el contrato: entradas requeridas, señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Trate esta etapa como un contrato entre las entradas y las salidas validadas. Asigne nombres a los artefactos, defina comprobaciones de éxito y rechace completaciones parciales silenciosas. Mida el recuerdo en un conjunto fijo de preguntas antes de ajustar los prompts. El cambio constante de prompts rara vez soluciona un sistema de recuperación deficiente.
El problema del chunking
Al trabajar en la etapa del Problema de Fragmentación, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Registre los tiempos y el costo de tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando el proceso pasa de la versión de demostración a entornos compartidos. Mida el rendimiento en un conjunto fijo de preguntas antes de ajustar los prompts. El cambio constante de prompts rara vez soluciona un sistema de recuperación deficiente.
Original text:
"...looking for a talented software engineer with 5 years of backend experience..."
Chunk 1 (chars 0-500): "...looking for a talented software engi"
Chunk 2 (chars 500-999): "neer with 5 years of backend experience..."
"Home About Careers Login Contact Us Senior Backend Eng"
Enfoques mejores:
Al trabajar en la etapa de enfoques mejorados, anote primero el contrato: los datos de entrada requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin tener que leer todo el sistema. Mida la tasa de recuperación con un conjunto fijo de preguntas antes de ajustar los prompts. El cambio constante de prompts rara vez soluciona un sistema de recuperación deficiente. Al trabajar en la etapa de enfoques mejorados, anote primero el contrato: los datos de entrada requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el fallo debe apuntar a una única responsabilidad y no a un proceso complicado.
Análisis completo con números reales
El “A Complete Walkthrough With stage” funciona mejor cuando se trata como una superficie medible. Capture un registro exitoso, un caso de fallo y la nota de reversión antes de ampliar el alcance. Considere esta etapa como un contrato entre las entradas y las salidas validadas. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas. Separe la política de fragmentación de la política de recuperación; cambiar una no debe obligar a reescribir la otra cuando cambian las métricas de calidad.
"Home Jobs Companies Senior Backend Engineer Wipro, Bengaluru
Build scalable APIs using Java Spring Boot. 5+ years experience required."
Tokenización (29 tokens):
La etapa de tokenización de 29 tokens funciona mejor cuando se trata como una métrica cuantificable. Capture una transcripción exitosa, un caso de fallo y la nota de reversión antes de ampliar el alcance. Registre los tiempos y el costo por token o consulta junto con los resultados funcionales. Tener visibilidad del costo desde temprano evita facturas inesperadas cuando el proceso pasa de la versión de demostración a entornos compartidos. Asigne un presupuesto de tokens por turno y por sesión. Las herramientas agenciales amplían el contexto de manera intensiva; los límites máximos impiden que las demostraciones se conviertan en facturas inesperadas.
["[CLS]", "home", "jobs", "companies", "senior", "backend", "engineer",
"wi", "##pro", ",", "bengal", "##uru", "build", "scala", "##ble",
"api", "##s", "using", "java", "spring", "boot", ".", "5", "+",
"years", "experience", "required", ".", "[SEP]"]
Vectores por token (se muestran 8 dimensiones en lugar de 384 para mayor legibilidad):
Los vectores por token que muestran 8 etapas funcionan mejor cuando se tratan como una superficie medible. Capture un transcripto ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de secretos y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin tener que leer todo el grafo. Establezca un límite de tokens por turno y por sesión. Las herramientas agentes amplían el contexto de manera excesiva; los límites estrictos evitan que las demostraciones se conviertan en facturas inesperadas.
"[CLS]" → [ 0.01, 0.03, -0.02, 0.05, 0.01, -0.04, 0.02, 0.06]
"home" → [ 0.44, 0.12, -0.33, 0.08, -0.21, 0.55, 0.09, -0.17]
"jobs" → [ 0.31, -0.05, 0.67, 0.22, 0.14, -0.08, 0.43, 0.11]
"companies" → [ 0.28, 0.09, 0.51, 0.18, 0.07, -0.12, 0.38, 0.05]
"senior" → [ 0.15, -0.22, 0.71, 0.33, 0.41, 0.09, 0.55, 0.27]
"backend" → [ 0.52, -0.18, 0.83, 0.45, 0.38, 0.21, 0.61, 0.34]
"engineer" → [ 0.48, -0.15, 0.79, 0.41, 0.35, 0.18, 0.58, 0.31]
"wi" → [ 0.11, 0.04, 0.22, 0.09, 0.03, 0.07, 0.14, 0.02]
"##pro" → [ 0.08, 0.02, 0.19, 0.06, 0.01, 0.05, 0.11, -0.01]
"," → [ 0.00, 0.01, 0.00, 0.01, -0.01, 0.00, 0.01, 0.00]
"bengal" → [ 0.39, 0.27, 0.55, 0.30, 0.22, 0.33, 0.41, 0.19]
"##uru" → [ 0.14, 0.10, 0.21, 0.11, 0.08, 0.12, 0.15, 0.07]
"build" → [ 0.35, -0.11, 0.62, 0.28, 0.19, 0.15, 0.47, 0.22]
"scala" → [ 0.29, -0.09, 0.54, 0.24, 0.16, 0.11, 0.40, 0.18]
"##ble" → [ 0.10, 0.03, 0.18, 0.07, 0.05, 0.04, 0.13, 0.06]
"api" → [ 0.41, -0.14, 0.73, 0.37, 0.30, 0.19, 0.53, 0.28]
"##s" → [ 0.03, 0.01, 0.05, 0.02, 0.01, 0.01, 0.04, 0.01]
"using" → [ 0.07, 0.02, 0.11, 0.04, 0.03, 0.02, 0.08, 0.03]
"java" → [ 0.46, -0.20, 0.77, 0.39, 0.32, 0.17, 0.56, 0.29]
"spring" → [ 0.42, -0.16, 0.70, 0.35, 0.28, 0.14, 0.51, 0.25]
"boot" → [ 0.38, -0.13, 0.65, 0.31, 0.25, 0.12, 0.48, 0.23]
"." → [ 0.00, 0.01, 0.00, 0.01, -0.01, 0.00, 0.01, 0.00]
"5" → [ 0.05, 0.01, 0.09, 0.03, 0.02, 0.01, 0.06, 0.02]
"+" → [ 0.01, 0.00, 0.02, 0.01, 0.00, 0.00, 0.01, 0.00]
"years" → [ 0.20, -0.07, 0.44, 0.19, 0.13, 0.08, 0.33, 0.14]
"experience" → [ 0.33, -0.10, 0.61, 0.27, 0.20, 0.13, 0.45, 0.21]
"required" → [ 0.18, -0.06, 0.39, 0.16, 0.11, 0.07, 0.29, 0.12]
"." → [ 0.00, 0.01, 0.00, 0.01, -0.01, 0.00, 0.01, 0.00]
"[SEP]" → [ 0.02, 0.01, -0.01, 0.03, 0.00, -0.02, 0.01, 0.04]
Los vectores por token que muestran 8 etapas funcionan mejor cuando se tratan como una superficie medible. Capture un transcripto ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando falla un paso, el fallo debe apuntar a una sola responsabilidad y no a un proceso complicado.
Pooling: 29 vectores se convierten en 1:
En el proceso de Pooling, 29 vectores pasan a formar una etapa; es necesario definir las entradas, el responsable de dicha etapa y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la etapa a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Considere esta etapa como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace cualquier completación parcial silenciosa. Cite los pasajes que realmente sustentan la respuesta. Sin citas, los operadores no podrán distinguir entre alucinaciones y lagunas en el indexado.
Dim 1: (0.01 + 0.44 + 0.31 + 0.28 + 0.15 + 0.52 + 0.48 + 0.11 + 0.08 + 0.00
+ 0.39 + 0.14 + 0.35 + 0.29 + 0.10 + 0.41 + 0.03 + 0.07 + 0.46 + 0.42
+ 0.38 + 0.00 + 0.05 + 0.01 + 0.20 + 0.33 + 0.18 + 0.00 + 0.02) / 29
= 0.231
Dim 2: (0.03 + 0.12 + -0.05 + 0.09 + -0.22 + -0.18 + -0.15 + 0.04 + 0.02 + 0.01
+ 0.27 + 0.10 + -0.11 + -0.09 + 0.03 + -0.14 + 0.01 + 0.02 + -0.20 + -0.16
+ -0.13 + 0.01 + 0.01 + 0.00 + -0.07 + -0.10 + -0.06 + 0.01 + 0.01) / 29
= -0.030... same for all 384 dimensions ...
Almacenado en la base de datos de vectores:
Para lo que se almacena en la etapa vectorial, defina las entradas, el responsable de la fase y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la fase a partir de un punto de control conocido sin tener que adivinar el estado oculto. Registre los tiempos de ejecución y el costo de tokens o consultas junto con los resultados funcionales. La visibilidad temprana del costo evita facturas inesperadas cuando el proceso pasa de entornos de demostración a entornos compartidos. Cite los pasajes que realmente sustentan la respuesta; sin citas, los operadores no pueden distinguir entre alucinaciones y brechas en el indexado.
text: "Home Jobs Companies Senior Backend Engineer Wipro, Bengaluru..."
vector: [0.231, -0.030, 0.421, 0.189, ...]
Ahora un usuario busca: “ingeniero senior de backend en Wipro”
En la fase de búsqueda por parte del usuario en Now, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea a partir de un punto de control conocido sin tener que adivinar el estado oculto. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben encontrarse en un único lugar que los operadores puedan auditar sin necesidad de leer todo el sistema. Mencione las secciones del texto que sirvieron como base para la respuesta. Sin citaciones, los operadores no podrán distinguir entre una alucinación y una laguna en el indexado. En la fase de búsqueda por parte del usuario en Now, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea a partir de un punto de control conocido sin tener que adivinar el estado oculto. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando una tarea falla, el error debe indicar una única responsabilidad y no un proceso complejo y entrelazado.
Query vector: [0.228, -0.028, 0.418, 0.185, ...]
Chunk vector: [0.231, -0.030, 0.421, 0.189, ...]
Dos modelos, dos tareas
Al trabajar en la fase de Dos modelos, dos tareas, anote primero el contrato: los datos de entrada requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Trate esta fase como un contrato entre los datos de entrada y los resultados validados. Asigne nombres a los artefactos, defina las comprobaciones de éxito y evite completar parcialmente el trabajo sin notificarlo. Almacene en caché las instrucciones del sistema estables y los esquemas de las herramientas. Reenviar un preámbulo idéntico es una causa común de sobrecarga.
Por qué es importante RAG
Al trabajar en la etapa de “¿Por qué es importante RAG?”, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Registre los tiempos y el costo en tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando se pasa de entornos de demostración a entornos compartidos. Mida el rendimiento en la recuperación de información con un conjunto fijo de preguntas antes de ajustar los prompts. Cambiar constantemente los prompts rara vez soluciona un sistema de recuperación deficiente.
¿Qué hace que un modelo de embedding sea bueno?
Al trabajar en la etapa de “¿Qué hace que algo sea bueno?”, anote primero el contrato: los insumos requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin tener que leer todo el sistema. Almacene en caché las instrucciones del sistema estables y los esquemas de las herramientas. Reenviar un preámbulo idéntico es una causa común de desperdicio de recursos. Al trabajar en la etapa de “¿Qué hace que algo sea bueno?”, anote primero el contrato: los insumos requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el fallo debe apuntar a una sola responsabilidad y no a un proceso complicado.
A: "Senior Backend Engineer at Wipro"
B: "Software Developer role in Bengaluru"
C: "Best chocolate cake recipe"
Lista de verificación operativa
Al trabajar en la fase de lista de verificación operativa, anote primero el contrato: los datos necesarios, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código.
Documente tanto el camino óptimo como el de recuperación. Los intentos repetidos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son ajustes realizados posteriormente.