Utforska data i en persistent kernel

Den här guiden visar hur du låter en agent läsa in något dyrt en gång och sedan ställa flera frågor till det, i stället för att betala för inläsningen vid varje fråga.

Verktyget eval kör en persistent tolk. Variabler, importer och inläst data överlever mellan anrop.

Varför inte bara köra ett skript

En engångskörning med python -c betalar för uppstarten vid varje fråga. Att läsa in en dataframe tar sekunder och hundra megabyte; att rita ett diagram av den tar millisekunder. När varje fråga kostar inläsningen ställer agenten färre frågor än den borde – och varje svar kommer tillbaka som text som den sedan måste parsa om.

Läs in en gång, fråga sedan

Läs in data/runs.csv och berätta p95-varaktigheten per agent.

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

Det sista uttrycket skrivs ut på samma sätt som i en notebook, så len(runs) rapporterar antalet rader utan en print.

Sedan, i ett separat anrop:

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

runs är fortfarande inläst. En pandas-DataFrame kommer tillbaka renderad som en tabell i stället för som en repr.

Diagram hamnar i chatten

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

Figurer fångas efter cellen och returneras som bilder, som transkriptet renderar. Du ser diagrammet; det gör agenten också.

Figurer stängs efter att de har fångats. En figur som inte samlats in skulle ritas om och skickas igen även av nästa cell, så en session på fem celler skulle skicka det första diagrammet fem gånger.

Ingen Jupyter, ingen pip, inget installationssteg

Köraren är en vanlig python3 -u som talar ett radprotokoll över stdio. Den implementerar display(), utskick av MIME-buntar och figurinsamling själv, så den fungerar på vilken Python 3 som helst – även i en sandlåda, där installation är precis det som sandlådan finns för att förhindra.

Idiomen du ändå skulle skriva

De här skrivs om till vanlig kod i stället för att ge fel:

Du skriver	Vad som händer
%pip install x	Kör pip och rensar sedan modulcachen så att nästa import ser den
%cd path	os.chdir
!command	En fångad subprocess
%%bash	Resten av cellen som ett skalskript
%%timeit	1000 tidsmätta körningar

Det är cacherensningen för %pip som spelar roll: att installera i en levande tolk gör ingenting för en modul som redan har importerats, så utan den är versionen du just installerade inte den som körs.

Anropa dina egna verktyg inifrån en cell

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

tool(name, args) går in i agentens eget verktygsregister igen. Det innebär att en cell kan sprida ut arbetet över hundra filer, eller delegera via task, utan att modellen gör av med en tur per objekt.

Bryggan kringgår inte dina räcken

Ett bryggat anrop löses mot samma verktygsregister som ett anrop utfärdat av modellen, så ActionClass-policy, godkännandeförfrågningar och varje wrapper gäller på samma sätt. En brygga som nådde förbi registret skulle vara ett hål format precis som ”skriv en Python-one-liner”.

Ett bryggat anrop pausar cellens tidsgräns medan det pågår. Budgeten mäter inaktivitet, inte klocktid – en cell som sprider ut arbetet till subagenter och väntar i fyra minuter har inte hängt sig, och att döda den mitt i utspridningen skulle förlora hela kernelns tillstånd.

Börja om

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

Kastar bort tolken och startar en ny, ren. Allt som har lästs in är borta, vilket är själva poängen.

Var kerneln körs

I samtalets avskilda miljö när det har en, annars på värden.

En persistent tolk som drivs av en modell som läser ett ej betrott repo är precis vad körning enbart i avskild miljö finns till för: ett engångsanrop till bash tar åtminstone slut, medan en kernel är ett skal som minns.

Den startar inte en avskild miljö för att komma dit – samma regel som hindrar en stationsflik från att starta automatiskt. Om du vill att kerneln ska köras avskilt öppnar du samtalets skal först. Se Ge en agent en maskin att testa på.

Gränser

• En cell i taget per kernel. Två celler som kapplöper i en och samma tolk är två halvor av två program som flätas samman i ett och samma namnutrymme.
• Utdata begränsas. En cell i en utskriftsslinga trunkeras i stället för att tillåtas fylla kontextfönstret.
• Fyra bilder per cell. En plottningsslinga kan skicka en figur per iteration, och varje bild är en stor fast kostnad i den begäran som bär den.
• Kerneln dör med körningen. En kernel som fortfarande håller en dataframe efter att samtalet har avslutats är en läcka.

Relaterat

• Sandlåda och säkerhet – vad ”avskilt” betyder här
• Ge en agent en maskin att testa på – att öppna den avskilda miljön
• Inbyggda agentverktyg – argumenten