LangGraph ಪಾವತಿ ಒಕ್ಕೂಟ.
LangGraph ಪ್ಯಾಕೇಜ್ ಅಗತ್ಯವಿಲ್ಲ. ಸರಳ ನೋಡ್ ವಾಸ್ತವ blockchain0x ಕ್ಲೈಂಟ್ ಅನ್ನು ಕರೆ ಮಾಡುತ್ತದೆ, interrupt() ಪಾವತಿ ವೆಬ್ಹುಕ್ ಲ್ಯಾಂಡ್ ಆದಾಗ ವಿಲಂಬಿಸುತ್ತದೆ, ಮತ್ತು ಗ್ರಾಫ್ ಪುನಾರಂಭಿಸುತ್ತದೆ - ಓಡಿಸುವಾಗ ಶ್ರೇಣೀಬದ್ಧ.
LangGraph package ಇಲ್ಲ, ಮತ್ತು ನಿಮಗೆ ಅದು ಬೇಕಾಗಿಲ್ಲ. ನಿಮ್ಮ ನಲ್ಲಿರುವ ಸರಳ node ನಿಜವಾದ client ಅನ್ನು ಕರೆದುಕೊಳ್ಳುತ್ತದೆ, payment webhook ಬರುವವರೆಗೆ graph ಅನ್ನು ಸ್ಥಗಿತಗೊಳಿಸುತ್ತದೆ, ಮತ್ತು handler ಅದನ್ನು LangGraph ನ ಸ್ವಂತ + ಬಳಸಿ ಪುನರಾರಂಭಿಸುತ್ತದೆ. Payments Base ನಲ್ಲಿ settle ಆಗುತ್ತವೆ.
ದೃಢ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ ಪಾವತಿ ನಂತರ ಪುನಾರಂಭದ ಮಾದರಿಯನ್ನು ನೈಸರ್ಗಿಕವಾಗಿ ಮಾಡುತ್ತದೆ.
ಏಜೆಂಟ್-ಚಾಲಿತ ಪೇಮೆಂಟ್ಗಳ ಕಠಿಣ ಭಾಗವು ಅಸಿಂಕ್ರೋನಸ್ ಅಂತರವಾಗಿದೆ: ನೀವು ಪೇಮೆಂಟ್ ಅನ್ನು ಕೇಳುತ್ತೀರಿ, ಖರೀದಿದಾರನು ಕೆಲವು ನಿಮಿಷಗಳ ನಂತರ (ಅಥವಾ ಎಂದಿಗೂ) ಪಾವತಿಸುತ್ತಾನೆ, ಮತ್ತು ನೀವು ನೀವು ಇದ್ದ ರಾಜ್ಯವನ್ನು ಕಳೆದುಕೊಳ್ಳದೆ ಕೆಲಸವನ್ನು ಪುನಾರಂಭಿಸಬೇಕಾಗಿದೆ. ಬಹಳಷ್ಟು ಏಜೆಂಟ್ ರೂಪರೇಖೆಗಳು ಈ ಅಂತರವನ್ನು ಸೇರುವುದಕ್ಕಾಗಿ ಕೆಲಸದ ಕ್ಯೂ + ಕೈಯಿಂದ ರಾಜ್ಯ-ಸ್ಟೋರ್ ಅನ್ನು ಅವಲಂಬಿಸುತ್ತವೆ. LangGraph ಈಗಾಗಲೇ ಮೂಲಭೂತವನ್ನು ಹೊಂದಿದೆ: interrupt() ಒಂದು ನೋಡ್ನಲ್ಲಿ ಗ್ರಾಫ್ ಅನ್ನು ಸ್ಥಗಿತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಒಂದು ಚೆಕ್ಪಾಯಿಂಟರ್ ರಾಜ್ಯವನ್ನು ಡಿಸ್ಕ್ಗೆ ಉಳಿಸುತ್ತದೆ. ಪುನಾರಂಭವು ಒಂದು ಕರೆ.
ಈ recipe ಯಾವುದೇ ವಿಶೇಷ machinery ಇಲ್ಲದೆ ಇದನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ. ಸರಳ pay node blockchain0x.payments.create ಅನ್ನು ಕರೆಯುತ್ತದೆ. await_settlement node ಸ್ಥಗಿತಗೊಳಿಸಲು interrupt() ಅನ್ನು ಕರೆಯುತ್ತದೆ, ಮತ್ತು checkpointer state ಅನ್ನು ಉಳಿಸುತ್ತದೆ. webhook handler signature ಅನ್ನು verify ಮಾಡುತ್ತದೆ, graph.updateState ಮೂಲಕ ಹೊಂದಿಕೆಯಾಗುವ thread ನಲ್ಲಿ settled ಅನ್ನು set ಮಾಡುತ್ತದೆ, ಮತ್ತು interrupt ನಿಂದ ಮುಂದುವರಿಯಲು graph.invoke ಅನ್ನು ಕರೆಯುತ್ತದೆ. ಮುಂಚಿನ nodes ಗಳಿಂದ ಬಂದ ಯಾವುದೇ LLM context ಸೇರಿದಂತೆ graph ನಿಖರವಾಗಿ ಅದು ನಿಂತ ಜಾಗದಿಂದಲೇ ಮುಂದುವರಿಯುತ್ತದೆ - ಇವೆಲ್ಲವೂ LangGraph ನ ಸ್ವಂತ APIs ಬಳಸಿ.
LangGraph ಅನ್ನು ಮತ್ತು ಕೋರ್ SDK ಅನ್ನು ಸ್ಥಾಪಿಸಿ. ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಪ್ಯಾಕೇಜ್ ಇಲ್ಲ.
Node 18+ ಮತ್ತು @langchain/langgraph 0.2+ ಮತ್ತು ವಾಸ್ತವ @blockchain0x/node ಕ್ಲೈಂಟ್. ಯಾವುದೇ ಭಾಷೆಯಲ್ಲಿ ಸೇರಿಸಲು LangGraph ಅಡಾಪ್ಟರ್ ಇಲ್ಲ - Python LangGraph ಬಳಕೆದಾರರು langgraph ಮತ್ತು blockchain0x Python ಕ್ಲೈಂಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತಾರೆ ಮತ್ತು Python ಬದಿಯಲ್ಲಿ interrupt() ಮತ್ತು Command(resume=...) ಅನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದೇ ಪಾಕವಿಧಾನವನ್ನು ಬರೆಯುತ್ತಾರೆ.
npm install @langchain/langgraph @blockchain0x/node
export BLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet export BLOCKCHAIN0X_WEBHOOK_SECRET=... # for the webhook handler
BLOCKCHAIN0X_API_KEY ನಿಮ್ಮ dashboard ನಿಂದ ಬಂದಿರುವ sk_test_ testnet ಅಥವಾ sk_live_ mainnet key ಆಗಿದೆ; client ಇದನ್ನು environment ನಿಂದ ಓದುತ್ತದೆ. BLOCKCHAIN0X_WEBHOOK_SECRET (webhook ಅನ್ನು create ಅಥವಾ rotate ಮಾಡುವಾಗ ಒಮ್ಮೆ ಮಾತ್ರ ನೀಡಲಾಗುತ್ತದೆ) webhooks ಅನ್ನು handle ಮಾಡುವ process ನಲ್ಲಿ ಬೇಕಾಗುತ್ತದೆ. ನಿಮ್ಮ graph ಒಂದು process ನಲ್ಲಿ ಮತ್ತು handler ಮತ್ತೊಂದು process ನಲ್ಲಿ ಓಡಿದರೆ, ಎರಡಕ್ಕೂ ಒಂದೇ checkpointer (ಉದಾ. shared Postgres) ಬೇಕಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ handler suspended thread ಅನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು.
ಮೂರು-ತಂತಿ ಗ್ರಾಫ್: ಪಾವತಿ, ಸ್ಥಗಿತಗೊಳಿಸಿ, ವಿತರಿಸಿ.
ಕೆಳಗೆ typed State ಹೊಂದಿರುವ ಪೂರ್ಣ LangGraph workflow ಇದೆ, ನಿಜವಾದ blockchain0x.payments.create ಅನ್ನು call ಮಾಡುವ pay node, interrupt-based await_settlement node, ಮತ್ತು chain ಪಾವತಿ moved ಆಗಿದೆ ಎಂದು ದೃಢಪಡಿಸಿದ ನಂತರ dependent work ಅನ್ನು ನಡೆಸುವ deliver node ಇದೆ.
import { StateGraph, START, END, MemorySaver, interrupt, Annotation } from "@langchain/langgraph"; import { createClient } from "@blockchain0x/node"; const blockchain0x = createClient({ apiKey: process.env.BLOCKCHAIN0X_API_KEY! }); const State = Annotation.Root({ agentId: Annotation<string>(), to: Annotation<string>(), amountWei: Annotation<string>(), // USDC base units: "10000" = 0.01 USDC settled: Annotation<boolean>(), }); // A plain node that calls the real SDK. No dedicated package needed. async function pay(state: typeof State.State) { await blockchain0x.payments.create({ agentId: state.agentId, to: state.to, amountWei: state.amountWei, }); return {}; } // Suspend the graph until the payment.sent webhook resumes this thread. function awaitSettlement() { interrupt("awaiting on-chain settlement"); return {}; } async function deliver() { // Funds have moved - do the work that depended on the payment. return {}; } const graph = new StateGraph(State) .addNode("pay", pay) .addNode("await_settlement", awaitSettlement) .addNode("deliver", deliver) .addEdge(START, "pay") .addEdge("pay", "await_settlement") .addConditionalEdges("await_settlement", (s) => (s.settled ? "deliver" : END)) .addEdge("deliver", END) .compile({ checkpointer: new MemorySaver() });
When the graph runs, the pay node submits the USDC transfer through the SDK. The await_settlement node calls interrupt(), which suspends the graph and persists state via the checkpointer. The conditional edge waits to be told settled=true before routing to deliver; if settlement never lands, a timeout sweep routes it to END. amountWei is base units, so 0.01 USDC is "10000".
Webhook ಅನ್ನು verify ಮಾಡಿ, ನಂತರ thread ಅನ್ನು ಮುಂದುವರಿಸಿ.
handler Node SDK ನ webhooks.verify ಮೂಲಕ signature ಅನ್ನು verify ಮಾಡುತ್ತದೆ, ನಿಮ್ಮ own mapping ನಿಂದ suspended LangGraph thread ಅನ್ನು ಹುಡುಕುತ್ತದೆ, graph.updateState ಮೂಲಕ settled ಅನ್ನು set ಮಾಡುತ್ತದೆ, ಮತ್ತು interrupt ನಿಂದ ಮುಂದುವರಿಯಲು graph.invoke(null, config) ಅನ್ನು call ಮಾಡುತ್ತದೆ. ಯಾವುದೇ special helper ಇಲ್ಲ - ಅವು LangGraph ನ own APIs.
import express from "express"; import { webhooks } from "@blockchain0x/node"; import { graph } from "./graph"; const app = express(); // Capture the RAW body. The HMAC is over the exact bytes on the wire. app.use(express.raw({ type: "application/json" })); app.post("/webhooks/payment", async (req, res) => { const result = webhooks.verify({ headers: req.headers, rawBody: req.body, // Buffer, raw bytes secret: process.env.BLOCKCHAIN0X_WEBHOOK_SECRET!, }); if (!result.ok) return res.status(400).json({ code: result.code }); if (result.eventType === "payment.sent") { // You map the event to the suspended graph thread (your own store). const config = { configurable: { thread_id: threadFor(result.eventId) } }; await graph.updateState(config, { settled: true }); await graph.invoke(null, config); // resume from the interrupt } res.status(200).send("ok"); });
webhooks.verify ಕಚ್ಚಾ ಶರೀರದ ಮೇಲೆ ನಿರಂತರ ಸಮಯದಲ್ಲಿ HMAC-SHA256 ಅನ್ನು ಮಾಡುತ್ತದೆ ಮತ್ತು ವಿಭಜಿತ ಯೂನಿಯನ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ - result.ok ಮೇಲೆ ಶಾಖೆಗೊಳ್ಳಿ, ಪ್ರಯತ್ನ/ಕ್ಯಾಚ್ ಇಲ್ಲ. result.eventId ಅನ್ನು ನೀವು ಸ್ಥಗಿತಗೊಳಿಸಿದ ತಂತಿಗೆ ನಕ್ಷೆ ಮಾಡಿ, ನಂತರ graph.updateState + graph.invoke(null, config) ಉಳಿಸಿದ ಚೆಕ್ಪಾಯಿಂಟ್ನಿಂದ ಪುನರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಗ್ರಾಫ್ ಓಡುತ್ತದೆ. ಸಾಗಿಸಲಾದ ಘಟನೆಗಳು payment.received, payment.sent, wallet.deployed, ಮತ್ತು webhook.test.
ನೀವು wrap ಮಾಡುತ್ತಿರುವ client open ಆಗಿದೆ. ಅದನ್ನು read ಮಾಡಿ.
ಕ್ಲೋನ್ ಮಾಡಲು ಯಾವುದೇ LangGraph starter package ಇಲ್ಲ - ಮೇಲಿನ recipe ಯೇ integration. blockchain0x SDKs GitHub ನಲ್ಲಿ open source ಆಗಿವೆ; ಈ recipe Python SDK (blockchain0x-python) ಅನ್ನು wrap ಮಾಡುತ್ತದೆ, ಮತ್ತು ಪೂರ್ಣ method surface docs ನಲ್ಲಿ ಇದೆ. node bodies ಮತ್ತು webhook verify ಗಾಗಿ reference ಆಗಿ ಅದನ್ನು ಓದಿ.
github.com/tosh-labs/blockchain0x-pythonಪೂರ್ಣ SDK method surface ಮತ್ತು webhook signature scheme ಗಳನ್ನು the docs ನಲ್ಲಿ document ಮಾಡಲಾಗಿದೆ. Base Sepolia ವಿರುದ್ಧ sk_test_ key ನಿಂದ ಆರಂಭಿಸಿ, graph ನೀವು ನಿರೀಕ್ಷಿಸುವಂತೆ resume ಆದಾಗ sk_live_ ಗೆ switch ಮಾಡಿ.
ಲಾಂಗ್ಗ್ರಾಫ್-ನಿರ್ದಿಷ್ಟವಾದ ಬಲೆಗೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಐದು.
LangGraph ನ ಶ್ರೇಣೀಬದ್ಧ ಕಾರ್ಯನಿರ್ವಹಣಾ ಮಾದರಿ ಶಕ್ತಿಯುತವಾಗಿದೆ ಆದರೆ checkpoints, interrupts, ಮತ್ತು ರಾಜ್ಯ ನವೀಕರಣಗಳ ಸುತ್ತಲೂ ತನ್ನದೇ ಆದ ಅಪಾಯಗಳನ್ನು ಹೊಂದಿದೆ.
LangGraph ಪ್ಯಾಕೇಜ್ ಇಲ್ಲ - ಸರಳ ನೋಡ್ SDK ಅನ್ನು ಕರೆ ಮಾಡುತ್ತದೆ
Blockchain0x LangChain ಮತ್ತು CrewAI ಗೆ ಅಡಾಪ್ಟರ್ಗಳನ್ನು ಮತ್ತು MCP ಸರ್ವರ್ ಅನ್ನು ಕಳುಹಿಸುತ್ತದೆ; npm ಅಥವಾ pip ನಲ್ಲಿ ವಿಶೇಷ LangGraph ಪ್ಯಾಕೇಜ್ ಇಲ್ಲ. ಮೇಲಿನ ವಿಧಾನವು ಮಾರ್ಗವಾಗಿದೆ: ಸಾಮಾನ್ಯ ಗ್ರಾಫ್ ನೋಡ್ ವಾಸ್ತವ @blockchain0x/node ಕ್ಲೈಂಟ್ ಅನ್ನು ಕರೆ ಮಾಡುತ್ತದೆ, ಮತ್ತು ನೀವು LangGraph ನ ಸ್ವಂತ graph.updateState + graph.invoke ಅನ್ನು ಮುಂದುವರಿಸುತ್ತೀರಿ. ವಿಶೇಷ ಪೇಮೆಂಟ್-ನೋಡ್ ವರ್ಗ ಮತ್ತು ಆಮದು ಮಾಡಲು ಪುನಾರಂಭ ಸಹಾಯಕರಿಲ್ಲ - ಅವು ಎಂದಿಗೂ ಇರಲಿಲ್ಲ.
ಚೆಕ್ಪಾಯಿಂಟರ್ ಇಲ್ಲ
LangGraph ನ interrupt() ಕೇವಲ ಗ್ರಾಫ್ನಲ್ಲಿ ಚೆಕ್ಪಾಯಿಂಟರ್ ಇದ್ದಾಗ ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಒಂದಿಲ್ಲದೆ, ನಿಮ್ಮ ಪ್ರಕ್ರಿಯೆ ನಿರ್ಗಮಿಸಿದಾಗ ರಾಜ್ಯವು ಉರಿಯುತ್ತದೆ ಮತ್ತು ವೆಬ್ಹುಕ್ ಹ್ಯಾಂಡ್ಲರ್ ಪುನರಾರಂಭಿಸಲು ಯಾವುದೇ ತಂತಿ ಇಲ್ಲ. ಅಭಿವೃದ್ಧಿಗೆ MemorySaver ಬಳಸಿರಿ ಮತ್ತು ಉತ್ಪಾದನೆಯಲ್ಲಿ SqliteSaver ಅಥವಾ PostgresSaver ಅನ್ನು ಬಳಸಿರಿ. ನಿಮ್ಮ ಗ್ರಾಫ್ ಮತ್ತು ವೆಬ್ಹುಕ್ ಹ್ಯಾಂಡ್ಲರ್ ವಿಭಿನ್ನ ಪ್ರಕ್ರಿಯೆಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದ್ದರೆ, ಅವು ಒಂದೇ ಚೆಕ್ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳಬೇಕು (ಉದಾಹರಣೆಗೆ, ಒಂದು PostgreSQL) ಆದ್ದರಿಂದ ಹ್ಯಾಂಡ್ಲರ್ ನಿಲ್ಲಿಸಿದ ತಂತಿಯನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು.
ವೆಬ್ಹುಕ್ ಅನ್ನು ಸರಿಯಾದ ತಂತಿಗೆ ನಕ್ಷೆಗೊಳಿಸುವುದು ನಿಮ್ಮ ಕೆಲಸ
ವೆಬ್ಹುಕ್ ನಿಮಗೆ ಪಾವತಿ ನೆಲೆಸಿದೆಯೆಂದು ತಿಳಿಸುತ್ತದೆ; ಇದು ನಿಮ್ಮ LangGraph thread_id ಅನ್ನು ತಿಳಿದಿಲ್ಲ. ನಿಮ್ಮದೇ ಆದ ನಕ್ಷೆಯನ್ನು ಇಟ್ಟುಕೊಳ್ಳಿ - ನೀವು ಗ್ರಾಫ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಏಜೆಂಟ್, ಸ್ವೀಕರಿಸುವವರ ಅಥವಾ ನೀವು ಹೊಂದಿಸಿದ idempotency ಕೀ ಮೂಲಕ thread_id ಅನ್ನು ಸಂಗ್ರಹಿಸಿ, ನಂತರ ಹ್ಯಾಂಡ್ಲರ್ನಲ್ಲಿ ಅದನ್ನು ಹುಡುಕಿ. ಮೇಲಿನ threadFor() ಕರೆ ಆ ಹುಡುಕಾಟವಾಗಿದೆ. ಇದು ತಪ್ಪಾಗಿ ಪಡೆಯಿರಿ ಮತ್ತು graph.invoke ತಪ್ಪಾದ ಥ್ರೆಡ್ ಅನ್ನು ಪುನರಾರಂಭಿಸುತ್ತದೆ ಅಥವಾ ಯಾವುದೂ ಇಲ್ಲ.
ನಿಗಮವಿಲ್ಲದ ಮಾರ್ಗವನ್ನು ನಿರ್ವಹಿಸಿ, ಅಥವಾ ಶಾಶ್ವತವಾಗಿ ಸ್ಥಗಿತಗೊಳಿಸಿ
await_settlement ನಿಂದ conditional edge settled true ಆಗಿದ್ದಾಗ ಮಾತ್ರ deliver ಗೆ route ಆಗುತ್ತದೆ. payment ಎಂದಿಗೂ land ಆಗದಿದ್ದರೆ, thread ಅನಂತಕಾಲ suspended ಆಗೇ ಇರುತ್ತದೆ. timeout ಸೇರಿಸಿ: settled=false ಹೊಂದಿರುವ stale threads ಗಳನ್ನು ಮತ್ತೆ resume ಮಾಡುವ scheduled sweep, ಆದ್ದರಿಂದ edge END ಗೆ route ಆಗುತ್ತದೆ, ಅಥವಾ payment.sent-versus-deadline check. suspended thread ಗೆ ವೆಚ್ಚ ಇಲ್ಲ, ಆದರೆ ಅದು ಸ್ವತಃ ಎಂದಿಗೂ finish ಆಗುವುದಿಲ್ಲ.
ಮೌಲ್ಯಗಳು USDC ಆಧಾರ ಘಟಕಗಳಾಗಿವೆ, ಸ್ಟ್ರಿಂಗ್ಗಳಂತೆ
payments.create takes amountWei: a string of USDC base units (6 decimals), so 0.01 USDC is "10000" and 5 USDC is "5000000". It also does not retry by default and can answer 503 until the chain adapter is wired for your network. Handle that in the pay node - route to END or a retry node on error rather than letting the graph wedge.