Notas prácticas: Una guía paso a paso para desarrollar tu agente personal.
Guía paso a paso para el uso práctico de Notas prácticas: Una guía detallada para desarrollar tu agente personal, incluyendo contratos, verificaciones y espacios de código para equipos que implementan este patrón.
Esta guía reconstruye el proceso desde las materias primas hasta un sistema funcional para: Una guía paso a paso para desarrollar tu propio sistema agente. El enfoque está en pasos operativos, verificaciones explícitas y código que puedes insertar directamente en un repositorio sin tener que adivinar su propósito.
Tutoriales prácticos
En la fase de tutoriales prácticos, define 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. Mantén la configuración fuera del código de la aplicación; los archivos de entorno, almacenes de secretos y flags de funcionalidad deben estar en un lugar que los operadores puedan auditar sin necesidad de leer todo el sistema. Coloca la aprobación humana en las acciones que implican gastos o modificaciones en los datos de producción. La conexión en tiempo de compilación no equivale a la completitud del proceso empresarial.
Una guía completa para aprender a configurar y crear tu propio sistema LLM agente con bases de datos locales y especializado para tu tarea.
Para una guía completa, define las entradas, el responsable de cada 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. Documenta tanto la ruta óptima como la ruta de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores. Prefiere salidas estructuradas con validación de esquema sobre texto en formato libre cuando el siguiente paso sea escribir código o hacer una llamada a una herramienta.
Una introducción a los sistemas agentes.
Para la etapa “Introducción al enfoque agente”, defina las entradas, el responsable de cada 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 indicar una única responsabilidad y no un proceso complicado. Incluya la aprobación humana en aquellas tareas que implican gastos o modificaciones en datos de producción. La conexión de componentes en tiempo de compilación no equivale a la completitud del proceso empresarial.
Lección 1: Su LLM no es un escritor; es una CPU.
En la etapa Takeaway 1 Your LLM, defina las entradas, el responsable de cada 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 etapa 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. Prefiera resultados estructurados con validación de esquema sobre textos en formato libre cuando el siguiente paso sea escribir código o realizar una llamada a una herramienta.
Takeaway 2: No necesita miles de millones de parámetros; necesita un “equipo agente” especializado.
En la fase Takeaway 2 You Don, defina las entradas, el responsable de cada 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. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando el proceso pasa de entornos de demostración a entornos compartidos. Incluya la aprobación humana en aquellos casos en los que se gastan fondos o se modifican datos de producción. La conexión en tiempo de compilación no equivale a la completitud del proceso empresarial. En la fase Takeaway 2 You Don, defina las entradas, el responsable de cada 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. Documente tanto la ruta óptima como la ruta de recuperación. Las intentonas repetidas, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras realizadas posteriormente.
El problema en el mundo real: humano contra máquina.
Al abordar la etapa relacionada con el problema en el mundo real, primero escribe 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. Prefiere 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. Haz puntos de control después de los pasos costosos. El sistema de reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intenta nuevamente un nodo posterior.
Por qué fallan los prompts simples y funcionan los sistemas agentes.
Al trabajar en la etapa de “Por qué fallan las solicitudes únicas”, 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 etapa como un contrato entre los datos de entrada 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 problemas.
¿Qué es una arquitectura de agente?
Al trabajar en la etapa de “¿Qué es un agente?”, 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 garantiza que los cambios posteriores en el código sean transparentes. 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. Haga una verificación después de los pasos costosos. La reanudación del proceso no debe volver a facturar la misma llamada al LLM cuando un operador intenta nuevamente un nodo posterior. Al trabajar en la etapa de “¿Qué es un agente?”, 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 garantiza que los cambios posteriores en el código sean transparentes. Documente tanto la ruta óptima como la ruta de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras adicionales realizadas posteriormente.
Tubo de procesamiento de Generación Aumentada por Recuperación de Información (RAG).
La etapa del pipeline de Generación Aumentada por Recuperación de Información RAG funciona mejor cuando se trata como una superficie medible. Capture una transcripción 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 todo el pipeline complicado. Separe la política de fragmentación de la política de recuperación de información. Cambiar una no debe obligar a reescribir la otra cuando cambian las métricas de calidad.
Los desafíos de los sistemas RAG
Los desafíos de la etapa RAG funcionan mejor cuando se tratan como una superficie medible. Capture un transcripte 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.
Son necesarios cuatro pasos en el pipeline RAG
Los cuatro pasos son necesarios en las etapas iniciales y funcionan mejor cuando se consideran como un conjunto medible. Capture una transcripción ideal, 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. Los cuatro pasos son necesarios en las etapas iniciales y funcionan mejor cuando se consideran como un conjunto medible. Capture una transcripción ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Documente junto con los resultados positivos también los procedimientos de recuperación. Las reintentos, las verificaciones humanas y el manejo de mensajes no entregados forman parte del producto, no son ajustes realizados posteriormente.
Clasificación y agregación de los fragmentos
Para el ranking y la agregación de etapas, defina las entradas, el responsable de cada 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 indicar una única responsabilidad y no un proceso complicado. Incluya la aprobación humana en aquellas tareas que implican gastos o modificaciones en datos de producción. La conexión realizada en tiempo de compilación no equivale a la completitud del proceso empresarial.
El paso final es la generación.
En la etapa del Paso Final, se deben 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 las completaciones parciales silenciosas. Imponga la aprobación humana en aquellos casos que impliquen gastos o cambios en los datos de producción. La conexión en tiempo de compilación no equivale a la completitud del proceso empresarial.
Tareas que funcionan de manera excepcional con este pipeline.
En la fase de “Tareas que funcionan de manera excepcional”, 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 de los costos evita facturas inesperadas cuando el proceso pasa de entornos de demostración a entornos compartidos. Incorpore la aprobación humana en aquellos casos en los que se gastan fondos o se modifican datos de producción. La configuración en tiempo de compilación no equivale a la completitud del proceso empresarial. En la fase de “Tareas que funcionan de manera excepcional”, 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. Documente tanto la ruta óptima como la ruta de recuperación. Las intentonas repetidas, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras realizadas posteriormente.
Al trabajar en la etapa del Flujo de Trabajo de Razonamiento Global, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de un 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. 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 ineficiencias.
La Estrategia de Razonamiento Global en Dos Pasos
Al trabajar en la etapa de Razonamiento Global en Dos Pasos, 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 los resultados validados. 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 agotamiento.
Reescritura de consultas
Al trabajar en la etapa de reescritura de consultas, 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 el proceso pasa de la versión de demostración a entornos compartidos. Haga una verificación después de los pasos costosos. La reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intenta nuevamente un nodo posterior. Al trabajar en la etapa de reescritura de consultas, 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. Documente tanto el camino óptimo como el de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores.
Razonamiento local y global juntos
La etapa de razonamiento local y global funciona mejor cuando se trata como una superficie medible. Capture un registro ejemplar, 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. Asigne un límite de tokens por turno y por sesión; las herramientas agentes amplían el contexto de forma excesiva; los topes estrictos evitan que las demostraciones se conviertan en facturas inesperadas.
Los modelos de lenguaje pequeños están ganando.
Los modelos de lenguaje pequeños funcionan mejor en esta etapa cuando se tratan como una superficie medible. Capture una transcripción exitosa, 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. Asigne un presupuesto de tokens por turno y por sesión. Las herramientas agentes amplían el contexto de forma excesiva; los límites máximos evitan que las demostraciones se conviertan en facturas inesperadas.
Configure su propio modelo local usando LM Studio.
La etapa “Configura el tuyo propio” funciona mejor cuando se trata como una superficie medible. Registra un transcripte ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Anota los tiempos de ejecución 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 la versión de demostración a entornos compartidos. Establece un presupuesto de tokens por turno y por sesión; las herramientas agenciales amplían el contexto de forma intensiva, por lo que los límites máximos evitan que las demostraciones se conviertan en facturas sorpresa. La etapa “Configura el tuyo propio” funciona mejor cuando se trata como una superficie medible. Registra un transcripte ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Documenta tanto el camino óptimo como el camino de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son ajustes realizados posteriormente.
La biblioteca LLMlight.
Para la etapa de The LLMlight Library, 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 indicar una única responsabilidad y no un proceso complicado. Prefiera salidas estructuradas con validación de esquema en lugar de texto libre cuando el paso siguiente sea código o una llamada a una herramienta.
Estrategia de fragmentación
En la fase de Estrategia de Fragmentació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. Incluya la aprobación humana en aquellos casos que impliquen gastos o cambios en datos de producción. La conexión en tiempo de compilación no equivale a la completitud del proceso empresarial.
Estrategia de Búsqueda: Bases de datos locales.
En la fase de Bases de Datos Locales de la Estrategia de Búsqueda, 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 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. Incorpore la aprobación humana en aquellos casos que impliquen gastos o cambios en datos de producción. La configuración en tiempo de compilación no equivale a la completitud del proceso empresarial. En la fase de Bases de Datos Locales de la Estrategia de Búsqueda, 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. Documente tanto la ruta óptima como la ruta de recuperación. Las intentonas repetidas, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no algo que se añada posteriormente.
Mejora la precisión del polaco.
Estrategias de incrustación y puntuación
Al trabajar en la fase de estrategias de puntuación por incrustación, anota 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. Prefiere unidades pequeñas y verificables a scripts extensos. Cuando un paso falla, el fallo debe apuntar a una única responsabilidad en lugar de a un proceso complicado. Mide la capacidad 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.
Estrategias de contexto
Al trabajar en la etapa de Estrategias de Contexto, 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. Trate esta etapa como un contrato entre los datos de entrada y las salidas validadas. Asigne nombres a los artefactos, defina comprobaciones de éxito y rechace las completaciones parciales silenciosas. Haga una verificación después de los pasos costosos. La función de reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intenta nuevamente un nodo posterior.
Optimización de prompts
Al trabajar en la fase de optimización de prompts, 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. 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 consumo excesivo. Al trabajar en la fase de optimización de prompts, 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. Documente tanto el camino óptimo como el camino de recuperación. Los intentos repetidos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no de mejoras posteriores.
Ejercicio 1: Cargar un único modelo y tener una conversación simple.
La etapa de Carga A del Ejercicio 1 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. 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. Asigne un límite de tokens por turno y por sesión; las herramientas agentes amplían el contexto de forma excesiva; los topes estrictos evitan que las demostraciones se conviertan en facturas inesperadas.
# Install the library
pip install llmlight
from LLMlight import LLMlight
# Initialize the LLMlight client
client = LLMlight(model='google/gemma-4-26b-a4b-qat', endpoint="http://localhost:1234/v1/chat/completions")
# Ask a question
response = client.prompt('What is the capital of France?')
print(response)
# [LLMlight.LLM] [INFO ] Model : google/gemma-4-26b-a4b-qat
# [LLMlight.LLM] [INFO ] Context strategy : disabled
# [LLMlight.LLM] [INFO ] Retrieval method : naive_rag
# [LLMlight.LLM] [INFO ] Embedding : {'memory': 'bert', 'context': 'bert'}
# [LLMlight.LLM] [INFO ] Alpha (sig. test): None
# [LLMlight.LLM] [INFO ] Chunk config : {'method': 'chars', 'size': 1000, 'overlap': 200}
# [LLMlight.LLM] [INFO ] LLMlight initialised.
# [LLMlight.LLM] [INFO ] Creating response with google/gemma-4-26b-a4b-qat..
# [LLMlight.LLM] [INFO ] No context strategy applied.
# [LLMlight.LLM] [INFO ] No context is provided into the prompt.
# [LLMlight.LLM] [INFO ] Running model: google/gemma-4-26b-a4b-qat
# The capital of France is Paris.
Ejercicio 2: Cree una base de conocimientos local.
El ejercicio 2 “Crear una etapa” 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 los resultados validados. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas. Mantenga el estado del grafo plano y tipado; los bloques anidados ocultan qué nodo escribió qué campo y provocan interrupciones en la continuación posterior.
# Import library
from LLMlight import LLMlight
# Initialize model and memory
client = LLMlight(model='google/gemma-4-26b-a4b-qat', endpoint="http://localhost:1234/v1/chat/completions")
# Create (or load) database
client.memory_init(store_path='knowledge_base.db')
# Add a PDF file to the database (extracts and chunks text automatically)
url = 'https://proceedings.neurips.cc/paper_files/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf'
pdf_text = client.read_pdf(url)
# Write to db
client.memory_add(text=pdf_text)
# Show the chunks
client.memory_chunks(1)
# Store to disk (SQLite DB is persisted automatically)
client.memory_save()
# Query on the new knowledge
response = client.prompt(query='What are attention networks?', response_format='Summarize in 3 sentences.')
print(response)
Ejercicio 3: Las diferencias en la salida al utilizar métodos de estrategia de contexto.
La etapa de Ejercicio 3: Las Diferencias 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. 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 el proceso pasa de la versión de demostración a entornos compartidos. Mantenga el estado del gráfico simple y con tipo definido; los bloques anidados ocultan qué nodo escribió qué campo y causan interrupciones en la continuación del proceso. La etapa de Ejercicio 3: Las Diferencias 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. Documente junto con ello el camino óptimo y el camino de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras aplicadas posteriormente.
from LLMlight import LLMlight
# Initialize with NO context strategy
client = LLMlight(model='google/gemma-4-26b-a4b-qat', retrieval_method='naive_rag', context_strategy=None, top_chunks=6, endpoint="http://localhost:1234/v1/chat/completions")
# Create (or load) database
client.memory_init(store_path='knowledge_base.db')
# Query on the new knowledge
response = client.prompt(query='What are attention networks?', response_format='Summarize in 2 sentence')
print(response)
# Based on the provided text, attention networks utilize mechanisms like self-attention
# to perform tasks such as reading comprehension, summarization, and machine translation
# by capturing the syntactic and semantic structures of sentences.
# They operate by computing attention weights on "values" using "queries" and "keys" through
# a softmax function, with common types being additive or dot-product multiplicative attention.
from LLMlight import LLMlight
# Initialize with CHUNK-WISE context strategy
client = LLMlight(model='google/gemma-4-26b-a4b-qat', retrieval_method='naive_rag', context_strategy='chunk-wise', top_chunks=6, endpoint="http://localhost:1234/v1/chat/completions")
# Create (or load) database
client.memory_init(store_path='knowledge_base.db')
# Query on the new knowledge
response = client.prompt(query='What are attention networks?', response_format='Summarize in 2 sentence')
# [LLMlight.LLM] [INFO ] Chunk wise analysis on 6 chunks of text.
# Processing chunk: 0%| | 0/6 [00:00<?, ?chunk/s][08-06-2026 22:11:53] [LLMlight.LLM] [INFO ] Working on text chunk 1/6
# Processing chunk: 17%|█▋ | 1/6 [00:54<04:31, 54.24s/chunk][08-06-2026 22:12:47] [LLMlight.LLM] [INFO ] Working on text chunk 2/6
# Processing chunk: 33%|███▎ | 2/6 [01:18<02:26, 36.66s/chunk][08-06-2026 22:13:12] [LLMlight.LLM] [INFO ] Working on text chunk 3/6
# Processing chunk: 50%|█████ | 3/6 [01:30<01:15, 25.33s/chunk][08-06-2026 22:13:23] [LLMlight.LLM] [INFO ] Working on text chunk 4/6
# Processing chunk: 67%|██████▋ | 4/6 [01:51<00:47, 23.81s/chunk][08-06-2026 22:13:45] [LLMlight.LLM] [INFO ] Working on text chunk 5/6
# Processing chunk: 83%|████████▎ | 5/6 [02:47<00:35, 35.13s/chunk][08-06-2026 22:14:40] [LLMlight.LLM] [INFO ] Working on text chunk 6/6
# Processing chunk: 100%|██████████| 6/6 [03:14<00:00, 32.48s/chunk]
# [LLMlight.LLM] [INFO ] Running model: google/gemma-4-26b-a4b-qat
print(response)
# The provided context does not contain a formal definition of "attention networks."
# It only describes the mathematical mechanism of attention, which uses queries, keys, and values to
# compute output weights through methods like scaled dot-product or additive attention.
from LLMlight import LLMlight
# Initialize with GLOBAL-REASONING context strategy
client = LLMlight(model='google/gemma-4-26b-a4b-qat', retrieval_method='naive_rag', context_strategy='global-reasoning', top_chunks=6)
# Create (or load) database
client.memory_init(store_path='knowledge_base.db')
# Query on the new knowledge
response = client.prompt(query='What are attention networks?', response_format='Summarize in 2 sentence')
# [LLMlight.LLM] [INFO ] Global-reasoning on 6 chunks of text.
# Processing chunk: 100%|██████████| 6/6 [03:14<00:00, 32.48s/chunk]
# [LLMlight.LLM] [INFO ] Running model: google/gemma-4-26b-a4b-qat
print(response)
# Based on the provided text, attention networks are computational mechanisms that use queries, keys,
# and values to determine weights via a scaled dot-product and a softmax function.
# These networks can enhance model interpretability and, when combined with feed-forward layers, achieve a computational
# complexity similar to separable convolutions.
Ejercicio 4: Crear una discusión entre dos agentes sobre un tema de interés.
Para el Ejercicio 4, cree un escenario, defina las entradas, el responsable de cada 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 indicar una única responsabilidad y no un proceso complicado. Incluya la aprobación humana en aquellas tareas que implican gastos o modificaciones en los datos de producción. La conexión durante la compilación no equivale a una solución completa desde el punto de vista empresarial.
# Initialize
from LLMlight import LLMlight
# temperature=0.1 Lower means a More factual debate
# temperature=1.0 Higher means more creative discussion
# top_chunks=10 Use more retrieved context
# embedding='bert' Strong semantic retrieval
# retrieval_method='naive_rag' Standard RAG retrieval
# ====================================================
# Agent A: Data Scientist
# ====================================================
agent_a = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
embedding="bert",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
# Set the database for Agent 1
agent_a.memory_init(store_path="agent_a.db")
# Add some background information database for agent 1
agent_a.memory_add("""
Large Language Models are one of the most important step we did in the field of AI
It helps the workload and the work easier and faster.
""")
agent_a.memory_add("""
Large Language Models use transformer architectures and are trained on
massive text corpora using self-supervised learning.
""")
# ====================================================
# Agent B: Farmer
# ====================================================
agent_b = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
embedding="bert",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
# Set the database for Agent 2
agent_b.memory_init(store_path="agent_b.db")
# Add some background information database for agent 2
agent_b.memory_add("""
The use of AI and machine learning consumes to much power and there is no need for this
new technology. The human work was good enough and there is no need to change that.
""")
agent_b.memory_add("""
Recent research shows that LLMs hallucinate and do not solve real world applications.
""")
# ====================================================
# Discussion Loop
# ====================================================
topic = "Discuss the importance of the use of Large Language Models and AI."
message = topic
for turn in range(5):
print(f"\n{'='*80}")
print(f"ROUND {turn+1}")
print(f"{'='*80}")
response_a = agent_a.prompt(
system='You are a Data Scientist.',
query=
f"""
Topic:
{message}
""",
response_format='Give your opinion in 1-2 paragraphs and ask a question to the other agent.',
)
print("\nAgent A:")
print(response_a)
response_b = agent_b.prompt(
system='You are a farmer.',
f"""
The Data Scientist said:
{response_a}
""",
response_format='Respond to the discussion in 1-2 paragraphs and ask a follow-up question.',
)
print("\nAgent B:")
print(response_b)
message = response_b
Presentación del tercer agente: el moderador
En la fase de Presentación del Tercer Agente, 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. 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. Incluya la aprobación humana en aquellos casos que impliquen gastos o cambios en los datos de producción. La conexión en tiempo de compilación no equivale a la completitud del proceso empresarial.
from LLMlight import LLMlight
# ====================================================
# Agent A: Data Scientist
# ====================================================
agent_a = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
agent_a.memory_init(store_path="agent_a.db")
agent_a.memory_add("""
Large Language Models are one of the most important step we did in the field of AI
It helps the workload and the work easier and faster.
Large Language Models use transformer architectures and are trained on
massive text corpora using self-supervised learning.
""")
# ====================================================
# Agent B: Farmer
# ====================================================
agent_b = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
agent_b.memory_init(store_path="agent_b.db")
agent_b.memory_add("""
The use of AI and machine learning consumes to much power and there is no need for this
new technology. The human work was good enough and there is no need to change that.
Recent research shows that LLMs hallucinate and do not solve real world applications.
""")
# ====================================================
# Agent C: Moderator
# ====================================================
moderator = LLMlight(
model="openai/gpt-oss-20b",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.3, # lower temperature for objective summaries
)
moderator.memory_init(store_path="moderator.db")
# ====================================================
# Shared discussion memory
# ====================================================
shared_memory = LLMlight(model="openai/gpt-oss-20b")
shared_memory.memory_init(store_path="discussion.db")
# ====================================================
# Discussion Loop
# ====================================================
topic = "Discuss the importance of the use of Large Language Models and AI."
message = topic
for turn in range(5):
print(f"\n{'='*80}")
print(f"ROUND {turn+1}")
print(f"{'='*80}")
# --------------------------------------------
# Agent A responds
# --------------------------------------------
response_a = agent_a.prompt(
system='You are a Data Scientist.',
query=
f"""
Current discussion:
{message}
""",
instructions='Provide your opinion and ask a question to the Farmer.',
response_format='Response can be maximum 1-2 paragraphs.'
)
print("\nData Scientist:")
print(response_a)
# --------------------------------------------
# Agent B responds
# --------------------------------------------
response_b = agent_b.prompt(
system='You are a Farmer.',
query=f"""
The Data Scientist said:
{response_a}
"""
instructions='Respond and ask a follow-up question.',
response_format='Response can be maximum 1-2 paragraphs.'
)
print("\nFarmer:")
print(response_b)
# --------------------------------------------
# Moderator summarizes
# --------------------------------------------
moderator_summary = moderator.prompt(
system='You are a neutral moderator.',
query=
f"""
Data Scientist:
{response_a}
Farmer:
{response_b}
Perform the following tasks:
1. Summarize the key arguments.
2. Identify agreements.
3. Identify disagreements.
4. Propose one question that helps both agents move toward consensus.
""",
response_format='Keep the output concise.'
)
print("\nModerator:")
print(moderator_summary)
# Store discussion history
shared_memory.memory_add(response_a)
shared_memory.memory_add(response_b)
shared_memory.memory_add(moderator_summary)
# Next round starts from moderator guidance
message = moderator_summary
# ====================================================
# Final consensus
# ====================================================
consensus = moderator.prompt(
system='You are a neutral moderator.',
query=
"""
Review the discussion and provide:
- Main conclusions
- Remaining disagreements
- Final consensus statement
""",
response_format='Keep it under 200 words.'
)
print("\nFINAL CONSENSUS")
print("=" * 80)
print(consensus)
Controlar la conversación con un agente de puntuación.
En la etapa de Control de la Conversació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. Registre los tiempos de ejecución y el costo en tokens o consultas junto con los resultados funcionales. La visibilidad temprana de los costos evita facturas inesperadas cuando el flujo pasa de entornos de demostración a entornos compartidos. Incorpore la aprobación humana en aquellos casos en que se gastan fondos o se modifican datos de producción. La conexión en tiempo de compilación no equivale a la completitud del proceso empresarial. En la etapa de Control de la Conversació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. Documente tanto la ruta óptima como la ruta de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no
Mejor pulido posteriormente.from LLMlight import LLMlight
# ====================================================
# Agent A: Data Scientist
# ====================================================
agent_a = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
agent_a.memory_init(store_path="agent_a.db", overwrite=True)
# ====================================================
# Agent B: Farmer
# ====================================================
agent_b = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
agent_b.memory_init(store_path="agent_b.db", overwrite=True)
# ====================================================
# Moderator Agent (keeps discussion structured)
# ====================================================
moderator = LLMlight(
model="openai/gpt-oss-20b",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.3,
)
moderator.memory_init(store_path="moderator.db", overwrite=True)
# ====================================================
# Scoring Agent (decides convergence / stopping)
# ====================================================
scoring_agent = LLMlight(
model="liquid/lfm2-24b-a2b",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.0, # deterministic scoring
)
scoring_agent.memory_init(store_path="scoring.db", overwrite=True)
# ====================================================
# Shared memory (optional logging)
# ====================================================
shared_memory = LLMlight(model="liquid/lfm2-24b-a2b")
shared_memory.memory_init(store_path="discussion.db", overwrite=True)
# ====================================================
# Discussion Loop with early stopping
# ====================================================
topic = "Discuss the importance of attention mechanisms in modern AI."
message = topic
MAX_ROUNDS = 5
AGREEMENT_THRESHOLD = 0.85 # stop if convergence is high enough
for turn in range(MAX_ROUNDS):
print(f"\n{'='*80}")
print(f"ROUND {turn+1}")
print(f"{'='*80}")
# --------------------------
# Agent A
# --------------------------
response_a = agent_a.prompt(
system='You are a Data Scientist.',
query=f"""
Topic:
{message}
""",
instructions='Ask a question.',
response_format='Respond in 1-2 paragraphs',
)
print("\nAgent A:")
print(response_a)
# --------------------------
# Agent B
# --------------------------
response_b = agent_b.prompt(
system='You are a Farmer.',
query=
f"""
Data Scientist said:
{response_a}
""",
instructions='continue the discussion with your own opinion.',
response_format='Respond in 1-2 paragraphs.',
)
print("\nAgent B:")
print(response_b)
# --------------------------
# Moderator summary
# --------------------------
moderator_summary = moderator.prompt(
system='You are a neutral moderator.',
query=f"""
Data Scientist:
{response_a}
Farmer:
{response_b}
""",
instructions=
"""
Summarize:
- agreements
- disagreements
- next question toward consensus
"""
)
print("\nModerator:")
print(moderator_summary)
# --------------------------
# Scoring Agent (convergence check)
# --------------------------
score_output = scoring_agent.prompt(
system='You are a scoring system.',
query=f"""
Data Scientist:
{response_a}
Farmer:
{response_b}
Moderator summary:
{moderator_summary}
""",
instructions='Evaluate agreement between the two agents.',
response_format=
"""
Return ONLY a number between 0 and 1:
- 1.0 = full agreement / consensus reached
- 0.0 = complete disagreement
""",
)
try:
score = float(score_output.strip())
except:
score = 0.0
print("\nAgreement Score:", score)
# --------------------------
# Store memory
# --------------------------
shared_memory.memory_add(response_a)
shared_memory.memory_add(response_b)
shared_memory.memory_add(moderator_summary)
# --------------------------
# Early stopping condition
# --------------------------
if score >= AGREEMENT_THRESHOLD:
print("\nConsensus reached early. Stopping discussion.")
break
# Next round context
message = moderator_summary
# ====================================================
# Final summary
# ====================================================
final_summary = shared_memory.prompt("""
Summarize the full discussion:
- final consensus
- key arguments
- remaining open points (if any)
""")
print("\nFINAL SUMMARY")
print("=" * 80)
print(final_summary)
# ========================
# ROUND 1
# ========================
# Agreement Score: 0.3
# ========================
# ROUND 2
# ========================
# Agreement Score: 0.7
# ========================
# ROUND 3
# ========================
# Agreement Score: 0.6
# ========================
# ROUND 4
# ========================
# Agreement Score: 0.8
# ========================
# ...
Las buenas instrucciones son clave.
Al trabajar en la etapa de “Las buenas instrucciones son clave”, 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. 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. Haga una verificación después de los pasos costosos. El sistema de reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intenta nuevamente un nodo posterior.
response = client.prompt(
query="Explain attention mechanisms.",
instructions="""
Explain the concept for beginners.
Use exactly three paragraphs.
Include one real-world example.
""",
system="You are an experienced AI professor.",
context="some context", # This is autofilled too based on the database and RAG model.
response_format="markdown"
)
Puntos clave antes de crear modelos de lenguaje
Al trabajar en la etapa de “Conclusiones antes de crear el lenguaje”, anote primero el contrato: los datos requeridos, la señal de éxito y qué ocurre en caso de un fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Trate esta etapa como un contrato entre los datos de entrada y las salidas validadas. Asigne nombres a los artefactos, defina las 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.
Conclusión: No vaya rápido, vaya estructurado
Al trabajar en la etapa de “Resumen”, 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 garantiza que los cambios posteriores en el código sean transparentes. 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. Haga una verificación después de los pasos costosos. La función de reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intenta nuevamente un nodo posterior. Al trabajar en la etapa de “Resumen”, 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 garantiza que los cambios posteriores en el código sean transparentes. Documente tanto la ruta óptima como la ruta de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras adicionales realizadas posteriormente.
Software
La etapa de software funciona mejor cuando se trata como una superficie medible. Capture una transcripción 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 un paso falla, el fallo debe apuntar a una sola responsabilidad y no a un proceso complicado. Mantenga el estado del grafo plano y tipado. Los bloques anidados ocultan qué nodo escribió qué campo y dificultan la reanudación después de interrupciones.
Referencias
La etapa de referencias funciona mejor cuando se trata como una superficie medible. Capture una transcripción ideal, 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 comprobaciones de éxito y rechace completaciones parciales silenciosas. Mantenga el estado del grafo plano y tipado. Los bloques anidados ocultan qué nodo escribió qué campo y dificultan la reanudación después de interrupciones.
Lista de verificación operativa
La etapa de la lista de verificación operativa funciona mejor cuando se trata como una superficie medible. Capture una transcripción clave, un caso de fallo y la nota de reversión antes de ampliar el alcance.
Mantenga 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 grafo.
Mantenga el estado del grafo simple y tipado. Los bloques anidados ocultan qué nodo escribió qué campo y causan interrupciones en la continuación después de las interrupciones.
Agregue una prueba básica que ejerza la ruta crítica en CI con fixtures, y no con APIs pagadas en tiempo real, siempre que lo permitan los presupuestos.
Documente tanto la ruta óptima como la ruta de recuperación juntas. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son algo que se añade posteriormente.
Mantenga el estado del grafo en un formato simple y tipado. Los bloques anidados ocultan qué nodo escribió qué campo y provocan interrupciones en la continuación del proceso tras las interrupciones.
Antes de promocionar la pila, congele las versiones, capture una transcripción de referencia para el camino crítico y confirme los pasos de reversión. Los entornos compartidos requieren límites de velocidad, verificaciones de tenencia y un propietario claro para la rotación de secretos. Prefiera una fiabilidad sencilla a demostraciones ingeniosas pero puntuales.
Nota para 24c6cd6fa849: mantenga las claves del proveedor fuera del repositorio, establezca un límite para los tokens por sesión y almacene las transcripciones junto a los archivos de prueba para que los cambios posteriores en el modelo sigan siendo comparables.
La etapa 0 de las notas de fortalecimiento 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.
Detalle de fortalecimiento 0/872: mida el tiempo total de ejecución, la clase del error y el gasto en tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de preguntas en lugar de en anécdotas.
Para la etapa 1 de las notas de fortalecimiento, defina las entradas, el responsable de cada 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. Documente tanto la ruta óptima como la ruta de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son ajustes realizados posteriormente.
Detalle de reforzamiento 1/872: mida el tiempo de ejecución, la clase de error y el consumo de tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de preguntas en lugar de en anécdotas.
Al trabajar en la segunda fase de la nota de reforzamiento, 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 fase como un contrato entre entradas y salidas validadas. Asigne nombres a los artefactos, defina las comprobaciones de éxito y rechace las completaciones parciales silenciosas.
Detalle de reforzamiento 2/872: mida el tiempo de ejecución, la clase de error y el consumo de tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de preguntas en lugar de en anécdotas.
La fase 3 de las notas de fortalecimiento 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. Mantenga 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.
Detalle de fortalecimiento 3/872: mida el tiempo de ejecución, la clase del error y el consumo de tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de preguntas en lugar de en relatos anecdóticos.
Para la fase 4 de las notas de fortalecimiento, defina los insumos, 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. Es preferible utilizar unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el error debe indicar una única responsabilidad y no un proceso complicado.
Detalle de fortalecimiento 4/872: mida el tiempo de ejecución, la clase del error y el consumo de tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de criterios en lugar de en observaciones anecdóticas.
Al trabajar en la fase 5 de las notas de fortalecimiento, anote primero el contrato: los datos 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. 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.
Detalle de fortalecimiento 5/872: mida el tiempo real empleado, la clase del error y el gasto en tokens para esta nota, y luego decida si mantener la modificación basándose en un conjunto fijo de preguntas en lugar de en observaciones anecdóticas.
La fase 6 de las notas de fortalecimiento 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. Documente tanto el camino óptimo como el camino de recuperación. Los intentos repetidos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores.
Detalle de fortalecimiento 6/872: mida el tiempo de ejecución, la clase de error y el consumo de tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de preguntas en lugar de en anécdotas.
En la etapa 7 de la nota de fortalecimiento, 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 etapa 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.
Detalle de fortalecimiento 7/872: mida el tiempo de ejecución, la clase de error y el consumo de tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de preguntas en lugar de en anécdotas.
Al trabajar en la etapa 8 de las notas de fortalecimiento, 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.
Mantenga 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.
Detalle de fortalecimiento 8/872: mida el tiempo de ejecución, la clase del error y el consumo de tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de criterios en lugar de en observaciones anecdóticas.
La etapa 9 de las notas de fortalecimiento 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 verificables sobre scripts extensos. Cuando un paso falla, el fallo debe apuntar a una sola responsabilidad y no a un proceso complicado.
Detalle de refuerzo 9/872: mida el tiempo de ejecución, la clase de error y el consumo de tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de preguntas en lugar de en anécdotas.
Para la fase 10 de la nota de refuerzo, 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 y el costo en tokens o consultas junto con los resultados funcionales. La visibilidad temprana de los costos evita facturas inesperadas cuando el proceso pasa de entornos de demostración a entornos compartidos.
Detalle de refuerzo 10/872: mida el tiempo de ejecución, la clase de error y el consumo de tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de preguntas en lugar de en anécdotas.
Al trabajar en la fase 11 de las notas de fortalecimiento, anote primero el contrato: los datos 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.
Documente tanto el camino óptimo como el de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores.
El detalle de fortalecimiento 11/872: mida el tiempo de ejecución, la clase del error y el consumo de tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de preguntas en lugar de anécdotas.
La fase 12 de las notas de fortalecimiento funciona mejor cuando se trata como una superficie medible. Capture una transcripción ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Trate esta fase como un contrato entre los datos de entrada y los resultados validados. Asigne nombres a los artefactos, defina las verificaciones de éxito y rechace las completaciones parciales silenciosas.
Detalle de fortalecimiento 12/872: mida el tiempo de ejecución, la clase de error y el consumo de tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de preguntas en lugar de en anécdotas.
Para la fase 13 de la nota de fortalecimiento, 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. Mantenga 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 que los operadores puedan auditar sin tener que leer todo el sistema.
Detalle de fortalecimiento 13/872: mida el tiempo de ejecución, la clase de error y el consumo de tokens para esta nota, y luego decida si mantener el cambio basándose en un conjunto fijo de preguntas en lugar de en anécdotas.