{"id":240,"date":"2026-01-07T04:44:54","date_gmt":"2026-01-06T20:44:54","guid":{"rendered":"https:\/\/connectword.dpdns.org\/?p=240"},"modified":"2026-01-07T04:44:54","modified_gmt":"2026-01-06T20:44:54","slug":"how-to-design-an-agentic-ai-architecture-with-langgraph-and-openai-using-adaptive-deliberation-memory-graphs-and-reflexion-loops","status":"publish","type":"post","link":"https:\/\/connectword.dpdns.org\/?p=240","title":{"rendered":"How to Design an Agentic AI Architecture with LangGraph and OpenAI Using Adaptive Deliberation, Memory Graphs, and Reflexion Loops"},"content":{"rendered":"

In this tutorial, we build a genuinely advanced Agentic AI system using LangGraph and OpenAI models by going beyond simple planner, executor loops. We implement adaptive deliberation, where the agent dynamically decides between fast and deep reasoning; a Zettelkasten-style agentic memory graph that stores atomic knowledge and automatically links related experiences; and a governed tool-use mechanism that enforces constraints during execution. By combining structured state management, memory-aware retrieval, reflexive learning, and controlled tool invocation, we demonstrate how modern agentic systems can reason, act, learn, and evolve rather than respond in a single pass. Check out the\u00a0FULL CODES here<\/a><\/strong>.<\/p>\n

\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
!pip -q install -U langgraph langchain-openai langchain-core pydantic numpy networkx requests\n\n\nimport os, getpass, json, time, operator\nfrom typing import List, Dict, Any, Optional, Literal\nfrom typing_extensions import TypedDict, Annotated\nimport numpy as np\nimport networkx as nx\nfrom pydantic import BaseModel, Field\nfrom langchain_openai import ChatOpenAI, OpenAIEmbeddings\nfrom langchain_core.messages import SystemMessage, HumanMessage, ToolMessage, AnyMessage\nfrom langchain_core.tools import tool\nfrom langgraph.graph import StateGraph, START, END\nfrom langgraph.checkpoint.memory import InMemorySaver<\/code><\/pre>\n<\/div>\n<\/div>\n
We set up the execution environment by installing all required libraries and importing the core modules. We bring together LangGraph for orchestration, LangChain for model and tool abstractions, and supporting libraries for memory graphs and numerical operations. Check out the\u00a0FULL CODES here<\/a><\/strong>.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
if not os.environ.get(\"OPENAI_API_KEY\"):\n   os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"Enter OPENAI_API_KEY: \")\n\n\nMODEL = os.environ.get(\"OPENAI_MODEL\", \"gpt-4o-mini\")\nEMB_MODEL = os.environ.get(\"OPENAI_EMBED_MODEL\", \"text-embedding-3-small\")\n\n\nllm_fast = ChatOpenAI(model=MODEL, temperature=0)\nllm_deep = ChatOpenAI(model=MODEL, temperature=0)\nllm_reflect = ChatOpenAI(model=MODEL, temperature=0)\nemb = OpenAIEmbeddings(model=EMB_MODEL)<\/code><\/pre>\n<\/div>\n<\/div>\n
We securely load the OpenAI API key at runtime and initialize the language models used for fast, deep, and reflective reasoning. We also configure the embedding model that powers semantic similarity in memory. This separation allows us to flexibly switch reasoning depth while maintaining a shared representation space for memory. Check out the\u00a0FULL CODES here<\/a><\/strong>.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
class Note(BaseModel):\n   note_id: str\n   title: str\n   content: str\n   tags: List[str] = Field(default_factory=list)\n   created_at_unix: float\n   context: Dict[str, Any] = Field(default_factory=dict)\n\n\nclass MemoryGraph:\n   def __init__(self):\n       self.g = nx.Graph()\n       self.note_vectors = {}\n\n\n   def _cos(self, a, b):\n       return float(np.dot(a, b) \/ ((np.linalg.norm(a) + 1e-9) * (np.linalg.norm(b) + 1e-9)))\n\n\n   def add_note(self, note, vec):\n       self.g.add_node(note.note_id, **note.model_dump())\n       self.note_vectors[note.note_id] = vec\n\n\n   def topk_related(self, vec, k=5):\n       scored = [(nid, self._cos(vec, v)) for nid, v in self.note_vectors.items()]\n       scored.sort(key=lambda x: x[1], reverse=True)\n       return [{\"note_id\": n, \"score\": s, \"title\": self.g.nodes[n][\"title\"]} for n, s in scored[:k]]\n\n\n   def link_note(self, a, b, w, r):\n       if a != b:\n           self.g.add_edge(a, b, weight=w, reason=r)\n\n\n   def evolve_links(self, nid, vec):\n       for r in self.topk_related(vec, 8):\n           if r[\"score\"] >= 0.78:\n               self.link_note(nid, r[\"note_id\"], r[\"score\"], \"evolve\")\n\n\nMEM = MemoryGraph()<\/code><\/pre>\n<\/div>\n<\/div>\n
We construct an agentic memory graph inspired by the Zettelkasten method, where each interaction is stored as an atomic note. We embed each note and connect it to semantically related notes using similarity scores. Check out the\u00a0FULL CODES here<\/a><\/strong>.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
@tool\ndef web_get(url: str) -> str:\n   import urllib.request\n   with urllib.request.urlopen(url, timeout=15) as r:\n       return r.read(25000).decode(\"utf-8\", errors=\"ignore\")\n\n\n@tool\ndef memory_search(query: str, k: int = 5) -> str:\n   qv = np.array(emb.embed_query(query))\n   hits = MEM.topk_related(qv, k)\n   return json.dumps(hits, ensure_ascii=False)\n\n\n@tool\ndef memory_neighbors(note_id: str) -> str:\n   if note_id not in MEM.g:\n       return \"[]\"\n   return json.dumps([\n       {\"note_id\": n, \"weight\": MEM.g[note_id][n][\"weight\"]}\n       for n in MEM.g.neighbors(note_id)\n   ])\n\n\nTOOLS = [web_get, memory_search, memory_neighbors]\nTOOLS_BY_NAME = {t.name: t for t in TOOLS}<\/code><\/pre>\n<\/div>\n<\/div>\n
We define the external tools the agent can invoke, including web access and memory-based retrieval. We integrate these tools in a structured way so the agent can query past experiences or fetch new information when necessary. Check out the\u00a0FULL CODES here<\/a><\/strong>.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
class DeliberationDecision(BaseModel):\n   mode: Literal[\"fast\", \"deep\"]\n   reason: str\n   suggested_steps: List[str]\n\n\nclass RunSpec(BaseModel):\n   goal: str\n   constraints: List[str]\n   deliverable_format: str\n   must_use_memory: bool\n   max_tool_calls: int\n\n\nclass Reflection(BaseModel):\n   note_title: str\n   note_tags: List[str]\n   new_rules: List[str]\n   what_worked: List[str]\n   what_failed: List[str]\n\n\nclass AgentState(TypedDict, total=False):\n   run_spec: Dict[str, Any]\n   messages: Annotated[List[AnyMessage], operator.add]\n   decision: Dict[str, Any]\n   final: str\n   budget_calls_remaining: int\n   tool_calls_used: int\n   max_tool_calls: int\n   last_note_id: str\n\n\nDECIDER_SYS = \"Decide fast vs deep.\"\nAGENT_FAST = \"Operate fast.\"\nAGENT_DEEP = \"Operate deep.\"\nREFLECT_SYS = \"Reflect and store learnings.\"<\/code><\/pre>\n<\/div>\n<\/div>\n
We formalize the agent\u2019s internal representations using structured schemas for deliberation, execution goals, reflection, and global state. We also define the system prompts that guide behavior in fast and deep modes. This ensures the agent\u2019s reasoning and decisions remain consistent, interpretable, and controllable. Check out the\u00a0FULL CODES here<\/a><\/strong>.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
def deliberate(st):\n   spec = RunSpec.model_validate(st[\"run_spec\"])\n   d = llm_fast.with_structured_output(DeliberationDecision).invoke([\n       SystemMessage(content=DECIDER_SYS),\n       HumanMessage(content=json.dumps(spec.model_dump()))\n   ])\n   return {\"decision\": d.model_dump(), \"budget_calls_remaining\": st[\"budget_calls_remaining\"] - 1}\n\n\ndef agent(st):\n   spec = RunSpec.model_validate(st[\"run_spec\"])\n   d = DeliberationDecision.model_validate(st[\"decision\"])\n   llm = llm_deep if d.mode == \"deep\" else llm_fast\n   sys = AGENT_DEEP if d.mode == \"deep\" else AGENT_FAST\n   out = llm.bind_tools(TOOLS).invoke([\n       SystemMessage(content=sys),\n       *st.get(\"messages\", []),\n       HumanMessage(content=json.dumps(spec.model_dump()))\n   ])\n   return {\"messages\": [out], \"budget_calls_remaining\": st[\"budget_calls_remaining\"] - 1}\n\n\ndef route(st):\n   return \"tools\" if st[\"messages\"][-1].tool_calls else \"finalize\"\n\n\ndef tools_node(st):\n   msgs = []\n   used = st.get(\"tool_calls_used\", 0)\n   for c in st[\"messages\"][-1].tool_calls:\n       obs = TOOLS_BY_NAME[c[\"name\"]].invoke(c[\"args\"])\n       msgs.append(ToolMessage(content=str(obs), tool_call_id=c[\"id\"]))\n       used += 1\n   return {\"messages\": msgs, \"tool_calls_used\": used}\n\n\ndef finalize(st):\n   out = llm_deep.invoke(st[\"messages\"] + [HumanMessage(content=\"Return final output\")])\n   return {\"final\": out.content}\n\n\ndef reflect(st):\n   r = llm_reflect.with_structured_output(Reflection).invoke([\n       SystemMessage(content=REFLECT_SYS),\n       HumanMessage(content=st[\"final\"])\n   ])\n   note = Note(\n       note_id=str(time.time()),\n       title=r.note_title,\n       content=st[\"final\"],\n       tags=r.note_tags,\n       created_at_unix=time.time()\n   )\n   vec = np.array(emb.embed_query(note.title + note.content))\n   MEM.add_note(note, vec)\n   MEM.evolve_links(note.note_id, vec)\n   return {\"last_note_id\": note.note_id}<\/code><\/pre>\n<\/div>\n<\/div>\n
We implement the core agentic behaviors as LangGraph nodes, including deliberation, action, tool execution, finalization, and reflection. We orchestrate how information flows between these stages and how decisions affect the execution path. Check out the\u00a0FULL CODES here<\/a><\/strong>.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
g = StateGraph(AgentState)\ng.add_node(\"deliberate\", deliberate)\ng.add_node(\"agent\", agent)\ng.add_node(\"tools\", tools_node)\ng.add_node(\"finalize\", finalize)\ng.add_node(\"reflect\", reflect)\n\n\ng.add_edge(START, \"deliberate\")\ng.add_edge(\"deliberate\", \"agent\")\ng.add_conditional_edges(\"agent\", route, [\"tools\", \"finalize\"])\ng.add_edge(\"tools\", \"agent\")\ng.add_edge(\"finalize\", \"reflect\")\ng.add_edge(\"reflect\", END)\n\n\ngraph = g.compile(checkpointer=InMemorySaver())\n\n\ndef run_agent(goal, constraints=None, thread_id=\"demo\"):\n   if constraints is None:\n       constraints = []\n   spec = RunSpec(\n       goal=goal,\n       constraints=constraints,\n       deliverable_format=\"markdown\",\n       must_use_memory=True,\n       max_tool_calls=6\n   ).model_dump()\n\n\n   return graph.invoke({\n       \"run_spec\": spec,\n       \"messages\": [],\n       \"budget_calls_remaining\": 10,\n       \"tool_calls_used\": 0,\n       \"max_tool_calls\": 6\n   }, config={\"configurable\": {\"thread_id\": thread_id}})<\/code><\/pre>\n<\/div>\n<\/div>\n
We assemble all nodes into a LangGraph workflow and compile it with checkpointed state management. We also define a reusable runner function that executes the agent while preserving memory across runs.<\/p>\n
In conclusion, we showed how an agent can continuously improve its behavior through reflection and memory rather than relying on static prompts or hard-coded logic. We used LangGraph to orchestrate deliberation, execution, tool governance, and reflexion as a coherent graph, while OpenAI models provide the reasoning and synthesis capabilities at each stage. This approach illustrated how agentic AI systems can move closer to autonomy by adapting their reasoning depth, reusing prior knowledge, and encoding lessons as persistent memory, forming a practical foundation for building scalable, self-improving agents in real-world applications.<\/p>\n
\n
Check out the\u00a0FULL CODES here<\/a><\/strong>.\u00a0Also,\u00a0feel free to follow us on\u00a0Twitter<\/mark><\/a><\/strong>\u00a0and don\u2019t forget to join our\u00a0100k+ ML SubReddit<\/a><\/strong>\u00a0and Subscribe to\u00a0our Newsletter<\/a><\/strong>. Wait! are you on telegram?\u00a0now you can join us on telegram as well.<\/a><\/strong><\/p>\n
Check out our latest release of\u00a0ai2025.dev<\/mark><\/strong><\/a>, a 2025-focused analytics platform that turns model launches, benchmarks, and ecosystem activity into a structured dataset you can filter, compare, and export<\/p>\n
The post How to Design an Agentic AI Architecture with LangGraph and OpenAI Using Adaptive Deliberation, Memory Graphs, and Reflexion Loops<\/a> appeared first on MarkTechPost<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"
In this tutorial, we build a g…<\/p>\n","protected":false},"author":1,"featured_media":29,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-240","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts\/240","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=240"}],"version-history":[{"count":0,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts\/240\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/media\/29"}],"wp:attachment":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=240"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=240"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=240"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}