Los agentes de IA no lanzan queries como los humanos
Los agentes de IA consultan ClickHouse® con muchos lookups pequeños por clave, en ráfagas en paralelo y con reintentos. En nuestras pruebas sobre un dataset de 200.000 millones de filas, una query de agente leyó unas 250 veces menos filas que la de un analista y tardó más o menos lo mismo. Dieciséis agentes en paralelo consiguieron menos del doble de respuestas que uno solo. Antes de dimensionar la base de datos para la velocidad de escaneo, dimensiónala para la concurrencia, la caché y el aislamiento que necesitan los agentes.
Casi todos los clusters de ClickHouse están afinados para una persona con un editor SQL: unos cuantos escaneos grandes por hora, un gráfico, un café y vuelta a escanear. Esa persona está dejando de ser la que más consulta, y los agentes atacan los mismos datos con un patrón para el que nadie dimensionó el cluster.
Rafa ya escribió sobre lo que ese volumen le hace a la factura del data warehouse y sobre qué hacer con los datos que escriben los agentes. Este post va de lo que le hace a la base de datos y de lo que hemos cambiado por ello.
Cómo consulta un agente de IA una base de datos
La sesión de un agente de IA contra una base de datos es un bucle: leer el schema, sondear una clave, tirar del hilo de lo que haya salido, arreglar la query que ha fallado y volver a preguntar.
Un analista abre el editor SQL sabiéndose ya las tablas, escribe una query que barre mucho, se pasa un minuto leyendo el resultado y escribe la siguiente. Un agente empieza de cero en cada sesión. Su primera llamada lee system.columns o lanza un DESCRIBE, la segunda es un sondeo acotado con LIMIT, y a partir de ahí salta con la entidad que ha encontrado a la siguiente tabla.
Si se equivoca con el nombre de una columna, recibe un error, relee el schema y lo vuelve a intentar. Si la respuesta no le cabe en la ventana de contexto, la vuelve a pedir más acotada. Los logs de nuestros propios agentes programados son prácticamente la transcripción de ese bucle.
Muchas lecturas pequeñas, de varios agentes a la vez y a cualquier hora.
Qué cambia cuando los agentes pasan a ser los que más consultan
El número de filas deja de predecir la latencia, la concurrencia pasa a ser el techo y el compute compartido deja de servir. Vimos las tres cosas al lanzar agentes y analistas contra el mismo dataset de 200.000 millones de filas.
La query mediana de un agente leyó 0,54 millones de filas. La de un analista, 134 millones. Y tardaron más o menos lo mismo. Aun así, un lookup por clave tiene que abrir todas las partes que puedan contener esa clave, y en una tabla de ese tamaño eso suponía cientos de partes para devolver 20 filas.
Luego añadimos agentes. Al pasar de una sesión de agente a dieciséis en paralelo, las queries enviadas se triplicaron y las respuestas no llegaron ni a duplicarse. Mientras estaba atascada, toda la flota leía menos de 1 GB por minuto: el cuello de botella era cuántos lookups podía tener el cluster en curso a la vez, muy por debajo de su ancho de banda.
El último resultado es el que le enseñaría a cualquiera que esté pensando en dar a sus agentes acceso al cluster donde corren sus informes. Con dos informes de analistas en marcha en los mismos nodos, ocho sesiones de agentes no consiguieron respuesta a un solo lookup en todo un minuto. Lo único que les llegó fueron las lecturas de schema.
Throughput: qué mueve el límite del tráfico de agentes
Hay dos palancas: menos viajes de ida y vuelta por lookup y menos vecinos pesados en la cola.
La primera es la caché. Repetir un lookup unos segundos después fue 12 veces más rápido, porque los datos ya estaban en nuestra caché distribuida. Los agentes releen lo que acaban de tocar: la entidad de la última llamada, el schema de la primera, la tabla de la que siguen tirando. Con una caché a la medida de ese working set, la mayoría de sus viajes de ida y vuelta se quedan en lecturas locales, y por eso dimensionamos nuestra caché distribuida por carga de trabajo, como contamos en nuestro setup de escalado. Con la caché dimensionada y el cluster ajustado, mil lookups aleatorios de direcciones sobre 203.000 millones de filas mantuvieron un p99 de 703 ms, ninguno por encima del segundo.
La segunda es el aislamiento. Los agentes trabajan en su propio compute sobre el mismo almacenamiento, así que el escaneo de un informe y el lookup de un agente no hacen la misma cola. Los datashares van un paso más allá cuando el agente lee datos de otro equipo: su servicio accede a las tablas compartidas en solo lectura, con su propio compute y sin copiar nada.
Coste: qué le hace el tráfico de agentes a la factura de ClickHouse
El precio por query castiga a los agentes. Cada llamada es una línea más en la factura, y en nuestras pruebas una sola pregunta de un agente se tradujo en siete queries, así que la factura engorda con cada agente que sumas.
Con precio por byte, una query de agente parece gratis, porque lee medio millón de filas. Pero ese modelo tampoco refleja dónde se va el dinero. Lo que consumen los agentes es capacidad concurrente: lookups en curso y memoria para mantener caliente su working set. Necesitas compute para las sesiones que tienes en pico, una caché lo bastante grande para lo que esas sesiones tocan una y otra vez y compute separado para que agentes e informes no se quiten recursos entre sí.
Nuestros precios funcionan así. Pagas el almacenamiento, y tú o tu agente provisionáis el compute que pide cada carga. La caché va en los discos NVMe de nodos que ya estás pagando, y no cobramos por query ni por byte escaneado. El desglose completo está en nuestro setup de costes. Resumido para agentes: estima cuántas sesiones tendrás en pico, dimensiona compute y caché para ellas y redimensiona cuando crezcan.
Schema e índices cuando los agentes son los que más consultan
La sort key decide a quién le salen baratas las queries.
Nuestra tabla de prueba estaba ordenada por cuenta y luego por tiempo. Los lookups de los agentes por cuenta tiraban del índice primario y leían poco. Una pregunta de un analista sobre el día anterior leyó quinientos millones de filas y no llegó a terminar, porque en una tabla ordenada primero por cuenta un filtro por tiempo solo puede descartar partes enteras.
Los agentes buscan por entidad: un usuario, una cuenta, una sesión, un pedido. En las tablas que consultan los agentes, pon esa entidad la primera en el ORDER BY y dale a las preguntas por tiempo su propio camino: un rollup o una projection ordenada por tiempo. Cuándo conviene cada cosa lo explicamos en índice vs projection vs vista materializada.
Mantén bajo el número de partes en las tablas de lookup. Las particiones mensuales tienen sentido en tablas de eventos con retención y backfills, pero cada partición es un sitio más donde un lookup por clave tiene que mirar. Con menos particiones y menos partes, pero más grandes, un lookup abre decenas de partes donde los nuestros abrían cientos.
No dejes que los rollups se multipliquen. Un equipo con el que hablamos mandó a los agentes de sus ingenieros a consultar tablas de rollup porque la de eventos iba demasiado lenta. Al cabo de un mes tenían decenas de rollups, varios refrescándose cada pocos minutos, y la base de datos saltaba por los aires más o menos una vez por semana. Haz que la tabla base sea lo bastante rápida para los lookups de agentes y deja los rollups para las preguntas que la gente hace cada semana.
Trata el schema como documentación, porque es la única que lee un agente. Lo que le devuelve DESCRIBE son los COMMENT de las columnas y sus nombres, así que más vale que sean claros. Una columna llamada amount_usd que guarda céntimos acabará en una respuesta equivocada dicha con total aplomo.
Para ver cómo se comporta tu propio tráfico de agentes, agrupa el query log por caller:
SELECT
coalesce(nullIf(log_comment, ''), nullIf(http_user_agent, ''), client_name) AS caller,
count() AS queries,
round(quantile(0.95)(query_duration_ms)) AS p95_ms,
quantile(0.5)(read_rows) AS median_rows,
round(avg(ProfileEvents['SelectedParts'])) AS avg_parts,
round(100 * avg(exception_code != 0), 1) AS error_pct
FROM system.query_log
WHERE event_time > now() - INTERVAL 1 DAY
AND type IN ('QueryFinish', 'ExceptionWhileProcessing')
AND query_kind = 'Select'
GROUP BY caller
ORDER BY queries DESC
LIMIT 20;
Un avg_parts alto con un median_rows bajo es la firma de un agente. Empieza por los callers que la tengan.
Límites de seguridad para los agentes
500 filas, 60 segundos, cuatro queries a la vez. Esos son los límites de la herramienta SQL con la que nuestros agentes consultan los datos de la empresa en ClickHouse:
| Ajuste | Valor | Por qué |
|---|---|---|
readonly | 1 | Bloquea las escrituras y las cláusulas SETTINGS con las que se saltarían el resto de límites desde el propio SQL |
max_execution_time | 60 s | Un agente perdido no puede quedarse un slot durante una hora |
| Tope de resultados | 500 filas, con aviso si se recorta | Mantiene las respuestas dentro de la ventana de contexto y le dice al agente que acote la query |
| Queries concurrentes por petición | 4 | Limita cuántas queries puede disparar en paralelo una sola petición |
| Errores | devueltos como datos, con una pista | Una columna desconocida vuelve con la pista de revisar los nombres, así que a la segunda el reintento sale bien |
log_comment | quién llama, en cada query | Permite leer el query log por caller |
Estos límites marcan cuánto te puede costar una sesión despistada. Por qué preferimos una sola herramienta SQL con buen contexto a decenas de herramientas específicas lo contamos en One powerful tool, not forty.
Con qué límite estás chocando y qué lo mueve
Si la latencia de los agentes sube con las sesiones pero se leen pocos bytes, el problema está en las partes y en la caché. Si los agentes se atascan mientras corren los informes, el culpable es el compute compartido.
| Síntoma | Qué revisar | Qué hacer |
|---|---|---|
| El p95 de los agentes crece con las sesiones y la CPU está ociosa | Partes por query, tasa de aciertos de caché | Caché dimensionada para el working set, menos partes y más grandes en las tablas de lookup |
| Los lookups de agentes van lentos, los informes van bien | Sort key frente al filtro del agente | ORDER BY que empiece por la entidad, o una projection ordenada por la entidad |
| Los agentes se atascan mientras corren los informes | Compute compartido | Compute separado para los agentes sobre el mismo almacenamiento |
| No paran de aparecer tablas de rollup | Quién creó cada una y para qué pregunta | Acelera el camino base y deja los rollups para preguntas humanas recurrentes |
| No distingues el tráfico de agentes del de personas | log_comment, http_user_agent, usuarios | Etiqueta cada query de agente en la herramienta |
Los agentes van camino de ser los que más consultan tu base de datos. Dimensiónala para la concurrencia, la caché y el aislamiento antes que para la velocidad de escaneo. ObsessionDB funciona justo así: almacenamiento con su propio precio, compute que tú o tus agentes provisionáis por carga de trabajo, una caché distribuida delante del object storage y grupos de compute separados sobre una sola copia de los datos. Si en tu query log ya aparecen agentes entre los callers, nuestra auditoría de costes lo lee por caller y te dice con cuál de estos límites estás chocando.
FAQ
Los agentes de IA lanzan muchas queries pequeñas por clave en vez de unos pocos escaneos grandes. En nuestra prueba sobre un dataset de 200.000 millones de filas, la query mediana de un agente leyó 0,54 millones de filas frente a 134 millones la de un analista. Los agentes también leen primero el schema, reintentan cuando algo falla y abren varias sesiones en paralelo.
Sí, si lo dimensionas para el patrón de los agentes. ClickHouse resuelve los lookups por clave con su índice primario, así que una sort key que empiece por la entidad les va muy bien. Los límites los pone la concurrencia: las partes que abre cada lookup, la tasa de aciertos de la caché y los agentes que comparten compute con informes pesados. En nuestra prueba nos topamos con ellos con la flota de agentes leyendo menos de 1 GB por minuto.
ClickHouse limita las queries concurrentes de todo el servidor con `max_concurrent_queries`, pero el tráfico de agentes se topa antes con un techo más bajo. En nuestras pruebas, dieciséis sesiones de agentes en paralelo no llegaron al doble de respuestas que una sola, y eso leyendo menos de 1 GB por minuto. El límite real lo marcan las partes que abre cada lookup y los viajes de ida y vuelta al object storage.
Acceso de solo lectura y con límites, sí. Nuestros agentes se conectan con `readonly=1`, un timeout de 60 segundos, resultados acotados, un máximo de cuatro queries a la vez por petición y una etiqueta `log_comment` en cada query. Lleva las sesiones de agentes a un compute separado para que un agente despistado no frene las queries que ven tus clientes.
Etiquétalas desde la herramienta. Pon `log_comment` en cada query que lance un agente, o dales a los agentes su propio usuario de ClickHouse, y agrupa `system.query_log` por esa etiqueta. Sin etiqueta, `http_user_agent` y `client_name` a veces delatan la librería cliente, pero casi nunca distinguen a un agente del ingeniero que lo ejecuta.
Los agentes traen más preguntas y más concurrencia, pero sus queries leen pocos datos. Si pagas por query, la factura sube con cada pregunta. Con compute provisionado, el coste depende de la capacidad que reserves para las sesiones en pico y para la caché, y cambia cuando la redimensionas.
Seguir Leyendo
Publicado originalmente en obsessionDB. Lee el artículo original aquí.
ClickHouse is a registered trademark of ClickHouse, Inc. https://clickhouse.com