| """Run the migrated agent against vLLM from the command line.
|
|
|
| python backend/run_agent.py "What was total revenue in FY2024?"
|
| python backend/run_agent.py --check # config + connectivity only
|
| python backend/run_agent.py --nodes "..." # per-node timing
|
|
|
| Exists so the migration can be verified without the HTTP layer in the way.
|
| """
|
|
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import asyncio
|
| import sys
|
| import time
|
| from pathlib import Path
|
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
|
|
| from backend.app.agent.graph import get_graph, run_config
|
| from backend.app.config import get_settings
|
|
|
|
|
| async def check() -> int:
|
| settings = get_settings()
|
| print("Configuration")
|
| print(f" vLLM {settings.vllm_base_url}")
|
| print(f" model {settings.vllm_model}")
|
| print(f" embeddings {settings.embedding_provider}")
|
| print(f" qdrant {settings.qdrant_url or settings.qdrant_path}")
|
| print(f" collection {settings.collection_name}")
|
| print(f" max_replans {settings.max_replans}")
|
| print(f" recursion_limit {settings.recursion_limit}")
|
|
|
| failures = 0
|
|
|
| print("\nConnectivity")
|
| try:
|
| from backend.app.agent.llm import chat_model
|
|
|
| t0 = time.perf_counter()
|
| reply = await chat_model(max_tokens=8).ainvoke("Reply with: ok")
|
| print(f" [OK] vLLM chat ({time.perf_counter() - t0:.2f}s) -> {reply.content!r}")
|
| except Exception as exc:
|
| print(f" [FAIL] vLLM chat: {type(exc).__name__}: {exc}")
|
| failures += 1
|
|
|
| try:
|
| from backend.app.agent.resources import collection_dimension
|
|
|
| dim = collection_dimension()
|
| print(f" [OK] Qdrant collection, {dim}-dim vectors")
|
| except Exception as exc:
|
| print(f" [FAIL] Qdrant: {type(exc).__name__}: {exc}")
|
| failures += 1
|
| dim = None
|
|
|
| try:
|
| from backend.app.agent.embeddings import embedding_dimension
|
|
|
| emb_dim = embedding_dimension()
|
| if dim is not None and emb_dim != dim:
|
| print(f" [FAIL] embeddings are {emb_dim}-dim but collection is {dim}-dim")
|
| failures += 1
|
| else:
|
| print(f" [OK] embeddings, {emb_dim}-dim")
|
| except Exception as exc:
|
| print(f" [FAIL] embeddings: {type(exc).__name__}: {exc}")
|
| failures += 1
|
|
|
| try:
|
| from backend.app.agent.resources import get_sql_database
|
|
|
| tables = get_sql_database().get_usable_table_names()
|
| print(f" [OK] SQLite tables: {tables}")
|
| except Exception as exc:
|
| print(f" [FAIL] SQLite: {type(exc).__name__}: {exc}")
|
| failures += 1
|
|
|
| print("\n" + ("all checks passed" if failures == 0 else f"{failures} check(s) failed"))
|
| return 1 if failures else 0
|
|
|
|
|
| async def stream_nodes(query: str) -> int:
|
| """Walk the graph, printing each node as it completes with its wall time."""
|
| settings = get_settings()
|
| print(f"Query: {query}\n")
|
|
|
| state = {"original_request": query, "replan_count": 0}
|
| started = time.perf_counter()
|
| last = started
|
| timings: dict[str, float] = {}
|
| final = None
|
|
|
| try:
|
| async for update in get_graph().astream(state, run_config()):
|
| now = time.perf_counter()
|
| for node, payload in update.items():
|
| elapsed = now - last
|
| timings[node] = timings.get(node, 0.0) + elapsed
|
| print(f" {node:<14} {elapsed:>6.2f}s", end="")
|
|
|
| if node == "planner" and payload.get("plan"):
|
| names = [s["tool_name"] for s in payload["plan"]]
|
| replans = payload.get("replan_count")
|
| suffix = f" (replan #{replans})" if replans else ""
|
| print(f" plan={names}{suffix}")
|
| elif node == "execute_tool" and payload.get("intermediate_steps"):
|
| step = payload["intermediate_steps"][-1]
|
| preview = str(step["tool_output"]).replace("\n", " ")[:90]
|
| print(f" {step['tool_name']} -> {preview}")
|
| elif node == "verify" and payload.get("verification_history"):
|
| audit = payload["verification_history"][-1]
|
| verdict = (
|
| "REPLAN"
|
| if audit["confidence_score"] < settings.audit_pass_score
|
| else "accept"
|
| )
|
| print(f" score={audit['confidence_score']}/5 {verdict}")
|
| elif node == "gatekeeper":
|
| q = payload.get("clarification_question")
|
| print(f" {'CLARIFY: ' + q[:70] if q else 'specific'}")
|
| else:
|
| print()
|
|
|
| if payload.get("final_response"):
|
| final = payload["final_response"]
|
| if payload.get("clarification_question"):
|
| final = "[clarification] " + payload["clarification_question"]
|
| last = now
|
| except asyncio.TimeoutError:
|
| print("\nAgent exceeded its wall-clock ceiling.")
|
| return 1
|
|
|
| total = time.perf_counter() - started
|
| print(f"\n{'-' * 70}\n{final}\n{'-' * 70}")
|
| print(f"total {total:.2f}s")
|
| for node, seconds in sorted(timings.items(), key=lambda kv: -kv[1]):
|
| print(f" {node:<14} {seconds:>6.2f}s {seconds / total * 100:>4.0f}%")
|
| return 0
|
|
|
|
|
| def main() -> int:
|
| parser = argparse.ArgumentParser(description=__doc__)
|
| parser.add_argument("query", nargs="?", help="Question to ask the agent")
|
| parser.add_argument("--check", action="store_true", help="Config and connectivity only")
|
| args = parser.parse_args()
|
|
|
| if args.check or not args.query:
|
| return asyncio.run(check())
|
| return asyncio.run(stream_nodes(args.query))
|
|
|
|
|
| if __name__ == "__main__":
|
| raise SystemExit(main())
|
|
|
