Datasets:
Formats:
parquet
Languages:
English
Size:
10K - 100K
Tags:
agriculture
plant-disease
crop-disease
vision-language-model
retrieval-augmented-generation
memory
License:
File size: 7,697 Bytes
c8e03af | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 | """Agentic memory: the SAGE agent loop with captions instead of reference images.
The agent sees the test image attached to its message (as in the retrieval run), the class list, the same KB text as the SAGE (KB only) condition, and a list of
memory caption files (one per labelled memory image, grouped by disease like SAGE's reference images). Its only tool
reads those text files (the working folder holds no images), and it may read up to k of them, choosing which itself (SAGE's own prompt and budget rules,
agmem/sage_prompt.py with medium="caption"). Claude Code CLI with the Read tool only; no other tools, settings or MCP.
Every call's full stream (messages, tool calls, tool results, final JSON) is stored with the cached result.
"""
from __future__ import annotations
import json
import os
import shutil
import subprocess
import time
from pathlib import Path
from . import config as C, data, llm, packet, prompts
from .sage_prompt import build_system_prompt, build_user_message
K_READS = 4
def _workdir(job, caps) -> tuple[Path, str, dict]:
files = {}
refs: dict[str, list[str]] = {}
for n, m in enumerate(sorted(job["memory"], key=lambda m: (m["label_shown"], m["image_id"]))):
cls = m["label_shown"]; rel = f"refs/{cls.replace(' ', '_')}/ref_{sum(1 for x in refs.get(cls, [])) + 1}.txt"
files[rel] = (packet.caption_text(caps[m["image_id"]]) or "(no visible description)").encode()
refs.setdefault(cls, []).append(rel)
key = llm.sha({"files": {k: llm.sha(v) for k, v in sorted(files.items())}})
wd = C.CACHE / "agentic_work" / key
if not wd.exists():
for rel, b in files.items():
(wd / rel).parent.mkdir(parents=True, exist_ok=True); (wd / rel).write_bytes(b)
return wd, key, {c: [str(wd / r) for r in v] for c, v in refs.items()}
def _parse(stdout: str):
trace, res = [], {}
for line in stdout.splitlines():
try:
ev = json.loads(line)
except json.JSONDecodeError:
continue
if ev.get("type") == "assistant":
for c in ev.get("message", {}).get("content", []):
if c.get("type") == "text" and c.get("text", "").strip():
trace.append({"type": "text", "content": c["text"]})
elif c.get("type") == "tool_use":
trace.append({"type": "tool_use", "tool": c.get("name"), "input": c.get("input", {})})
elif ev.get("type") == "user":
for c in ev.get("message", {}).get("content", []) if isinstance(ev.get("message", {}).get("content"), list) else []:
if c.get("type") == "tool_result":
body = c.get("content")
if isinstance(body, list):
body = [b.get("text", "[image]") if b.get("type") == "text" else "[image]" for b in body]
trace.append({"type": "tool_result", "content": body})
elif ev.get("type") == "result":
res = ev
return trace, res
def diagnose(crop, classes, kbd, caps, job, k=K_READS, max_turns=None, reserve_usd=0.45) -> dict:
wd, files_key, refs = _workdir(job, caps)
kb_text, _ = packet.build(crop, kbd, caps[job["image_id"]], None) # identical KB to the SAGE condition
system = build_system_prompt(k=k, medium="caption")
user = build_user_message("TEST", classes, refs, kb_text, k, medium="caption")
head = user.split("## Possible Classes")[0]
user = user.replace(head, "## Test Image\n\nThe test image is attached above this message.\n\n")
img = llm.image_block(data.path(job["image_id"]))
kd = {"m": C.MODEL, "agentic": 2, "s": system, "u": user, "img": llm.sha(img["source"]["data"]), "files": files_key}
if max_turns:
kd["max_turns"] = max_turns # hard bound on turns, so on captions exposed (one Read per turn)
key = llm.sha(kd)
cp = C.CACHE / "agentic_out" / f"{key}.json"
if cp.exists() and llm.looks_failed(json.loads(cp.read_text()).get("text"), False) and json.loads(cp.read_text()).get("num_turns") == 1:
cp.unlink() # a cached usage-limit reply is not an outcome
if cp.exists():
out = json.loads(cp.read_text()); hit = True
llm._ledger({"key": key, "stage": "diag:agentic", "tag": job["job_id"], "cache_hit": True, "cost_usd": 0.0, "t": time.time()})
else:
llm.reserve(reserve_usd)
cmd = ["claude", "-p", "--model", C.MODEL, "--input-format", "stream-json", "--output-format", "stream-json", "--verbose", "--no-session-persistence",
"--tools", "Read", "--allowedTools", "Read", "--strict-mcp-config", "--setting-sources", "", "--system-prompt", system]
if max_turns:
cmd += ["--max-turns", str(max_turns)]
env = {k_: v for k_, v in os.environ.items() if not k_.startswith(("CLAUDE", "CURSOR", "MCP_CONNECTION", "VSCODE", "ELECTRON"))}
env["DISABLE_PROMPT_CACHING"] = "1"; t0 = time.time()
msg = {"type": "user", "message": {"role": "user", "content": [img, {"type": "text", "text": user}]}}
try:
p = subprocess.run(cmd, input=json.dumps(msg).encode(), capture_output=True, env=env, timeout=600, cwd=str(wd))
finally:
llm.release(reserve_usd)
trace, res = _parse(p.stdout.decode(errors="replace"))
if not res:
raise RuntimeError(f"agent produced no result: rc={p.returncode} {p.stderr.decode()[:300]}")
hit_turn_bound = res.get("subtype") == "error_max_turns"
if not hit_turn_bound and llm.looks_failed(res.get("result", ""), res.get("is_error")):
llm._ledger({"key": key, "stage": "diag:agentic", "tag": job["job_id"], "cache_hit": False, "failed": True,
"cost_usd": float(res.get("total_cost_usd") or 0.0), "text": str(res.get("result", ""))[:200], "t": time.time()})
raise llm.CallFailed(str(res.get("result", ""))[:200])
out = {"text": res.get("result", ""), "trace": trace, "cost_usd": float(res.get("total_cost_usd") or 0.0),
"num_turns": res.get("num_turns"), "usage": res.get("usage"), "model_ids": list((res.get("modelUsage") or {}).keys()),
"elapsed_s": round(time.time() - t0, 1), "system_prompt": system, "user_message": user, "workdir": str(wd),
"hit_turn_bound": hit_turn_bound, "max_turns": max_turns}
cp.parent.mkdir(parents=True, exist_ok=True); cp.write_text(json.dumps(out))
llm._ledger({"key": key, "stage": "diag:agentic", "tag": job["job_id"], "cache_hit": False, "cost_usd": out["cost_usd"],
"num_turns": out["num_turns"], "elapsed_s": out["elapsed_s"], "model_ids": out["model_ids"], "t": time.time()})
hit = False
reads = [t["input"].get("file_path", "") for t in out["trace"] if t["type"] == "tool_use" and t["tool"] == "Read"]
cap_reads = [r for r in reads if r.endswith(".txt")]
pred = prompts.clean_prediction(llm.parse_json(out["text"]), classes)
return {**{k_: v for k_, v in job.items() if k_ != "memory"}, **pred, "correct": pred["prediction"] == job["label"],
"k_budget": k, "caption_reads": len(cap_reads), "read_classes": [Path(r).parent.name.replace("_", " ") for r in cap_reads],
"non_caption_reads": [r for r in reads if not r.endswith(".txt")], "over_budget": len(cap_reads) > k,
"memory_pool_size": len(job["memory"]), "num_turns": out.get("num_turns"), "cost_usd": 0.0 if hit else out["cost_usd"], "hit_turn_bound": out.get("hit_turn_bound", False),
"elapsed_s": out.get("elapsed_s"), "usage": out.get("usage"),
"cache_hit": hit, "model_ids": out.get("model_ids"), "trace_key": key}
|