Explorar dados em um kernel persistente

Este guia mostra como fazer um agente carregar algo caro uma única vez e depois fazer várias perguntas sobre esse algo, em vez de pagar o carregamento a cada pergunta.

A ferramenta eval executa um interpretador persistente. Variáveis, importações e dados carregados sobrevivem entre chamadas.

Por que não apenas rodar um script

Um python -c pontual paga a preparação a cada pergunta. Carregar um dataframe custa segundos e cem megabytes; plotá-lo custa milissegundos. Quando cada pergunta custa o carregamento, um agente faz menos perguntas do que deveria — e cada resposta volta como texto que ele precisa analisar de novo.

Carregue uma vez, depois pergunte

Carregue data/runs.csv e me diga a duração p95 por agente.

import pandas as pd
runs = pd.read_csv("data/runs.csv")
len(runs)

A última expressão é ecoada como um notebook faz, então len(runs) informa a contagem de linhas sem um print.

Depois, em uma chamada separada:

runs.groupby("agent")["duration_ms"].quantile(0.95).sort_values()

runs continua carregado. Um frame do pandas volta renderizado como tabela, e não como um repr.

Os gráficos aparecem no chat

import matplotlib.pyplot as plt
runs.groupby("agent")["duration_ms"].mean().plot.bar()

As figuras são capturadas depois da célula e devolvidas como imagens, que a transcrição renderiza. Você vê o gráfico; o agente também.

As figuras são fechadas após a captura. Uma figura não coletada seria redesenhada e reenviada pela próxima célula também, então uma sessão de cinco células emitiria o primeiro gráfico cinco vezes.

Sem Jupyter, sem pip, sem etapa de instalação

O executor é simplesmente python3 -u, falando um protocolo de linhas em stdio. Ele mesmo implementa display(), o despacho de pacotes MIME e a captura de figuras, então funciona em qualquer Python 3 — inclusive dentro de um sandbox onde instalar é exatamente o que o sandbox existe para impedir.

As sintaxes que você digitaria de qualquer forma

Estas são reescritas como código comum em vez de gerar erro:

Você digita	O que acontece
%pip install x	Executa o pip e então limpa o cache de módulos para que o próximo import o veja
%cd path	os.chdir
!command	Um subprocesso capturado
%%bash	O resto da célula como um script de shell
%%timeit	1000 execuções cronometradas

A remoção de cache do %pip é a que importa: instalar em um interpretador vivo não faz nada por um módulo que já foi importado, então sem ela a versão que você acabou de instalar não é a que está rodando.

Chamar suas próprias ferramentas de dentro de uma célula

paths = tool("find", {"pattern": "**/*.dart", "path": "lib"})
for path in paths.splitlines()[:100]:
    contents = tool("read", {"path": path})
    ...

tool(name, args) entra novamente no registro de ferramentas do próprio agente. Isso significa que uma célula pode se distribuir por cem arquivos, ou delegar por meio de task, sem que o modelo gaste um turno por item.

A ponte não contorna as suas barreiras

Uma chamada via ponte é resolvida contra o mesmo registro de ferramentas que uma chamada emitida pelo modelo, então a política de ActionClass, as solicitações de aprovação e todos os wrappers se aplicam de forma idêntica. Uma ponte que passasse por cima do registro seria um buraco com exatamente o formato de “escreva um one-liner em Python”.

Uma chamada via ponte suspende o timeout da célula enquanto está pendente. O orçamento mede a inatividade, não o tempo de relógio — uma célula que se distribui para subagentes e espera quatro minutos não está travada, e matá-la no meio da distribuição perderia todo o estado do kernel.

Começar de novo

eval(code: "…", reset: true, description: "Start a clean interpreter")

Descarta o interpretador e inicia um novo, limpo. Tudo o que foi carregado se perde, e é justamente essa a ideia.

Onde o kernel roda

No recinto da conversa quando ela tem um; caso contrário, no host.

Um interpretador persistente conduzido por um modelo que lê um repositório não confiável é exatamente para isso que existe a execução apenas em recinto: uma chamada bash pontual ao menos termina, enquanto um kernel é um shell que se lembra.

Ele não inicializa um recinto para chegar até lá — a mesma regra que impede uma aba de rig de iniciar automaticamente. Se você quer o kernel dentro de um recinto, abra primeiro o shell da conversa. Consulte Dar a um agente uma máquina para testar.

Limites

• Uma célula por vez por kernel. Duas células disputando um mesmo interpretador são duas metades de dois programas intercaladas em um único namespace.
• A saída tem limite. Uma célula em um loop de print é truncada em vez de poder encher a janela de contexto.
• Quatro imagens por célula. Um loop de plotagem pode emitir uma figura por iteração, e cada imagem é um custo fixo alto na requisição que a carrega.
• O kernel morre com a execução. Um kernel que ainda segura um dataframe depois que a conversa terminou é um vazamento.

Relacionados

• Sandbox e segurança — o que “dentro do recinto” significa aqui
• Dar a um agente uma máquina para testar — abrir o recinto
• Ferramentas de agente integradas — os argumentos