This paper presents a full implementation of the code to design a graph-structured agent using Gemini, for task planning, retrieval and computation.

import os, json, time, ast, math, getpass
Import dataclasses and fields
Typing import List, Dict or Callable
import google.generativeai as genai


try:
 Import networkx as Nx
If you get an ImportError, it's because your import is not working.
 Nox = None

Make a model using the API key (api_key) and Model Name. "gemini-1.5-flash"):
   genai.configure(api_key=api_key)
   return genai.GenerativeModel(model_name, system_instruction=(
       "You are GraphAgent, a principled planner-executor. "
       "Prefer structured, concise outputs; use provided tools when asked."
   ))


def call_llm(model, prompt: str, temperature=0.2) -> str:
   r = model.generate_content(prompt, generation_config={"temperature": temperature})
 Text return "").strip()

def safe_eval_math(expr: str) -> str:
 Node = ast.parse() (expr), mode="eval")
 Allow = (ast.Expression ast.BinOp ast.UnaryOp ast.Num ast.Constant)
              ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Pow, ast.Mod,
              ast.USub, ast.UAdd, ast.FloorDiv, ast.AST)
   def check(n):
 If isinstance()(n) does not exist: Raise ValueError ("Unsafe expression")
       for c in ast.iter_child_nodes(n): check(c)
   check(node)
   return str(eval(compile(node, "$",\; "eval"),\; \{"\_\_builtins\_\_":\; \{\}\},\; \{\}))\; DOCS\; =\; [\; "Solar\; panels\; convert\; sunlight\; to\; electricity;\; capacity\; factor\; ~20\%.",\; "Wind\; turbines\; harvest\; kinetic\; energy;\; onshore\; capacity\; factor\; ~35\%.",\; "RAG\; =\; retrieval-augmented\; generation\; joins\; search\; with\; prompting.",\; "LangGraph\; enables\; cyclic\; graphs\; of\; agents;\; good\; for\; tool\; orchestration.",\; ]\; def\; search\_docs(q:\; str,\; k:\; int\; =\; 3)\; ->\; List[str]:\; ql\; =\; q.lower()\; Score\; =\; sort(DOCS\; key=lambda,\; d:\; w\; in\; lower\; d.()\; For\; w,\; split\; ql.()))\; Return\; Score[:k]$

@dataclass
CLASS STATE:
   task: str
 Plan: str = ""
 The scratch-off List[str] = field(default_factory=list)
 Evidence: List[str] = field(default_factory=list)
 result: str = ""
 Integer = 0, step
 If bool is False, the result will be:


def node_plan(state: State, model) -> str:
   prompt = f""The user's task can be solved by planning step-bystep.Return JSON
Task: {state.task}
Return JSON: {{"subtasks": ["..."], "tools": {{"search": true/false, "math": true/false}}, "success_criteria": ["..."]}}"""
   js = call_llm(model, prompt)
   try:
       plan = json.loads(js[js.find("{"): js.rfind("}")+1])
 The exception:
       plan = {"subtasks": ["Research", "Synthesize"], "tools": {"search": True, "math": False}, "success_criteria": ["clear answer"]}
   state.plan = json.dumps(plan, indent=2)
   state.scratch.append("PLAN:n"+state.plan)
 Return to the Homepage "route"


def node_route(state: State, model) -> str:
   prompt = f""You are a Router. Choose the next node.
Context scratch:n{chr(10).join(state.scratch[-5:])}
If math needed -> 'math', if research needed -> 'research', if ready -> 'write'.
One token can be returned from [research, math, write]. Task: {state.task}"""
   choice = call_llm(model, prompt).lower()
 If "math" Choose any (ch.isdigit)() "Ch" in the state.task
 Return to the Homepage "math"
 If "research" Evidence:
 Return to the Homepage "research"
 Return to the Homepage "write"


def node_research(state: State, model) -> str:
   prompt = f""Generate 3 targeted search queries to:
Task: {state.task}
As a JSON string list, return the strings."""
   qjson = call_llm(model, prompt)
   try:
       queries = json.loads(qjson[qjson.find("["): qjson.rfind("]")+1])[:3]
 The exception:
       queries = [state.task, "background "+state.task, "pros cons "+state.task]
 Hits = []
   for q in queries:
       hits.extend(search_docs(q, k=2))
   state.evidence.extend(list(dict.fromkeys(hits)))
   state.scratch.append("EVIDENCE:n- " + "n- ".join(hits))
 Return to the Homepage "route"


def node_math(state: State, model) -> str:
   prompt = "Extract a single arithmetic expression from this task:n"+state.task
 Expr = call_llm(model, prompt)
   expr = ""Joining a ch with an expr is possible by using.join. "0123456789+-*/().%^ ")
   try:
 Safe_eval_math (expr).
       state.scratch.append(f"MATH: {expr} = {val}")
 Other than Exceptions as follows:
       state.scratch.append(f"MATH-ERROR: {expr} ({e})")
 Return to the Homepage "route"


def node_write(state: State, model) -> str:
   prompt = f""Write the answer.
Task: {state.task}
Cite the math and evidence below. [1],[2].
Evidence:n{chr(10).join(f'[{i+1}] '+e for i,e in enumerate(state.evidence))}
Notes:n{chr(10).join(state.scratch[-5:])}
Please provide a structured, short answer."""
   draft = call_llm(model, prompt, temperature=0.3)
 Draft = state.result
   state.scratch.append("DRAFT:n"+draft)
 Return to the Homepage "critic"


def node_critic(state: State, model) -> str:
   prompt = f""The answer should be improved for its factuality and missing steps.
The improved response will be returned if a fix is required. Otherwise, return the 'OK" answer.
Answer:n{state.result}nCriteria:n{state.plan}"""
   crit = call_llm(model, prompt)
 If crit.strip().upper() != "OK" and len(crit) > 30:
       state.result = crit.strip()
       state.scratch.append("REVISED")
 state.done is True
 Return to the Homepage "end"


Nodes:[str, Callable[[State, Any], str]] = {
   "plan": node_plan, "route": node_route, "research": node_research,
   "math": node_math, "write": node_write, "critic": node_critic
}


def run_graph(task: str, api_key: str) -> State:
   model = make_model(api_key)
 state = State (task=task
 Cur = "plan"
   max_steps = 12
   while not state.done and state.step  plan -> route -> (research  route) & (math  route) -> write -> critic -> END
"""

If __name__ is equal to "__main__":
 Key = os.getenv()"GEMINI_API_KEY") or getpass.getpass("🔐 Enter GEMINI_API_KEY: ")
 Task = input ("📝 Enter your task: ").strip() The following are some examples of how to use "Compare solar vs wind for reliability; compute 5*7."
   t0 = time.time()
   state = run_graph(task, key)
   dt = time.time() - t0
   print("n=== GRAPH ===", ascii_graph())
   print(f"n✅ Result in {dt:.2f}s:n{state.result}n")
   print("---- Evidence ----")
   print("n".join(state.evidence))
   print("n---- Scratch (last 5) ----")
   print("n".join(state.scratch[-5:]))