LangGraph பணம் செலுத்தும் இணைப்பு.
LangGraph தொகுப்பு தேவை இல்லை. ஒரு சாதாரண நொடி உண்மையான blockchain0x கிளையனை அழைக்கிறது, interrupt() செலுத்தும் வெப்ஹூக் தரையில் விழும் வரை இடைநிறுத்துகிறது, மற்றும் கிராப் மீண்டும் தொடங்குகிறது - இயக்கங்களில் நிலைத்திருக்கிறது.
LangGraph package எதுவும் இல்லை, மேலும் உங்களுக்கு அது தேவையுமில்லை. உங்கள் -இல் உள்ள ஒரு plain node உண்மையான client-ஐ call செய்கிறது, ஒரு payment webhook வரும் வரை graph-ஐ suspend செய்கிறது, மேலும் handler அதை LangGraph-ன் சொந்த + மூலம் resume செய்கிறது. Payments Base-இல் settle ஆகும்.
திடமான செயல்பாடு, பணம் செலுத்திய பிறகு மீண்டும் தொடங்கும் மாதிரியை இயற்கையாக மாற்றுகிறது.
முகவர்-ஊக்குவிக்கப்பட்ட செலுத்தல்களின் கடினமான பகுதி அசிங்க் இடைவெளி: நீங்கள் செலுத்தலைக் கோரிக்கையிடுகிறீர்கள், வாங்குபவர் சில நிமிடங்களில் (அல்லது ஒருபோதும்) செலுத்துகிறார், மற்றும் நீங்கள் எங்கு இருந்தீர்கள் என்பதை இழக்காமல் வேலை தொடர வேண்டும். பெரும்பாலான முகவர் கட்டமைப்புகள் இந்த இடைவெளியை மூடுவதற்காக வேலை வரிசை + கைமுறையாக நிலை-அங்கீகாரத்தை நம்புகின்றன. LangGraph இல் ஏற்கனவே அடிப்படையாகக் கட்டமைக்கப்பட்டுள்ளது: interrupt() ஒரு நொடியிலுள்ள கிராப் ஐ இடைநிறுத்துகிறது மற்றும் ஒரு சரிபார்ப்பாளர் நிலையை டிஸ்கில் நிலைத்திருக்கிறது. மீண்டும் தொடங்குவது ஒரு அழைப்பு.
இந்த recipe இதை எந்த special machinery-யும் இல்லாமல் பயன்படுத்துகிறது. ஒரு plain pay node blockchain0x.payments.create-ஐ அழைக்கிறது. await_settlement node suspend செய்ய interrupt()-ஐ அழைக்கிறது, மேலும் checkpointer நிலையை சேமிக்கிறது. webhook handler signature-ஐ verify செய்து, பொருந்தும் thread-ல் graph.updateState மூலம் settled-ஐ அமைத்து, 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-ஐ கையாளும் process-க்கு தேவை. உங்கள் graph ஒரு process-இல் இயங்கி, handler மற்றொரு process-இல் இயங்கினால், இரண்டுக்கும் ஒரே checkpointer (எ.கா. shared Postgres) தேவைப்படும், இதனால் handler நிறுத்தப்பட்ட thread-ஐ கண்டுபிடிக்க முடியும்.
மூன்று-தண்டவாள வரைபடம்: செலுத்து, நிறுத்து, வழங்கு.
கீழே ஒரு complete LangGraph workflow உள்ளது, இதில் typed State, real blockchain0x.payments.create-ஐ அழைக்கும் pay node, interrupt-based await_settlement node, மற்றும் chain payment நகர்ந்ததை உறுதிப்படுத்திய பிறகு 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".
வெப்கோக்னை சரிபார்க்கவும், பின்னர் தண்டவாளத்தை மீண்டும் தொடங்கவும்.
கையாளி Node SDK இல் இருந்து webhooks.verify உடன் கையொப்பத்தை சரிபார்க்கிறது, உங்கள் சொந்த வரைபடத்தில் இருந்து ஒதுக்கப்பட்ட LangGraph நூலைப் பார்க்கிறது, graph.updateState உடன் நிலைமையாக்குகிறது, மற்றும் இடைஞ்சலிலிருந்து தொடர graph.invoke(null, config) ஐ அழைக்கிறது. எந்த சிறப்பு உதவியாளர் இல்லை - அவை LangGraph இன் சொந்த 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 RAW உடலின் மீது நிலையான நேரத்தில் HMAC-SHA256 ஐ செய்கிறது மற்றும் ஒரு வேறுபட்ட யூனியனைக் கொண்டுவருகிறது - result.ok இல் கிளை செய்யவும், முயற்சி/பிடிக்கவில்லை. result.eventId ஐ நீங்கள் நிறுத்திய தண்டவாளத்திற்கு வரைபடம் செய்யவும், பின்னர் graph.updateState + graph.invoke(null, config) நிலையான சோதனைச் சோதனையிலிருந்து மீண்டும் தொடங்குகிறது மற்றும் வரைபடம் இயக்கங்கள் வழங்குகிறது. அனுப்பப்பட்ட நிகழ்வுகள் payment.received, payment.sent, wallet.deployed மற்றும் webhook.test ஆக உள்ளன.
நீங்கள் சுற்றி வைக்கும் கிளையன் திறந்தது. அதைப் படிக்கவும்.
Clone செய்ய 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 இல் ஆவணப்படுத்தப்பட்டுள்ளன. Base Sepolia-வில் sk_test_ key-யுடன் தொடங்கி, பின்னர் graph நீங்கள் எதிர்பார்த்தபடி மீண்டும் தொடர்ந்ததும் sk_live_ க்கு மாற்றவும்.
தவிர்க்க வேண்டிய ஐந்து LangGraph-சிறப்பு சிக்கல்கள்.
LangGraph-ன் நிலையான செயல்பாட்டு மாதிரி சக்திவாய்ந்தது ஆனால் சோதனைச் சோதனைகள், இடைநிறுத்தங்கள், மற்றும் மாநில புதுப்பிப்புகளைச் சுற்றி தனது சொந்த பாதைகள் உள்ளன.
LangGraph தொகுப்பு இல்லை - ஒரு சாதாரண நொடி SDK ஐ அழைக்கிறது
Blockchain0x LangChain மற்றும் CrewAI க்கான அடாப்டர்களை மற்றும் MCP சேவையகத்தை அனுப்புகிறது; npm அல்லது pip இல் தனிப்பட்ட LangGraph தொகுப்பு இல்லை. மேலே உள்ள செய்முறை பாதை: ஒரு சாதாரண கிராப் நோடு உண்மையான @blockchain0x/node கிளையண்டை அழைக்கிறது, மற்றும் நீங்கள் LangGraph இன் சொந்த graph.updateState + graph.invoke உடன் தொடர்கிறீர்கள். தனிப்பட்ட கட்டண-நோடு வகை மற்றும் இறக்குமதி செய்ய உதவும் மீண்டும் இல்லை - அவை எப்போது இருந்ததில்லை.
சோதனைச் சோதனைக்கூடம் காணவில்லை
LangGraph இன் இடைநிறுத்தம்() செயல்படுவதற்கு, கிராப் ஒரு சரிபார்ப்பாளர் கொண்டிருக்க வேண்டும். ஒன்றுமில்லாமல், உங்கள் செயல்முறை வெளியேறும்போது மாநிலம் விலகும் மற்றும் வெப்ஹுக் கையாளுநருக்கு மீண்டும் தொடங்குவதற்கு எந்தத் தந்தையும் இல்லை. மேம்பாட்டிற்காக MemorySaver ஐப் பயன்படுத்தவும், உற்பத்தியில் SqliteSaver அல்லது PostgresSaver ஐப் பயன்படுத்தவும். உங்கள் கிராப் மற்றும் வெப்ஹுக் கையாளுநர் மாறுபட்ட செயல்களில் இயங்கினால், அவர்கள் ஒரே சரிபார்ப்பாளரைப் பகிர வேண்டும் (எ.கா. ஒரு Postgres) எனவே கையாளுநர் இடைநிறுத்தப்பட்ட தந்தையை கண்டுபிடிக்க முடியும்.
வெப்ஹூக்கைப் சரியான தந்தைக்கு வரைபடம் செய்யுவது உங்கள் வேலை
webhook உங்களுக்கு ஒரு பணம் தீர்வு செய்யப்பட்டதாகச் சொல்கிறது; இது உங்கள் LangGraph thread_id ஐ அறியவில்லை. உங்கள் சொந்த வரைபடத்தை வைத்திருக்கவும் - நீங்கள் ஒரு வரைபடத்தை தொடங்கும் போது, முகவர், பெறுபவர், அல்லது நீங்கள் அமைத்த idempotency விசை மூலம் thread_id ஐ சேமிக்கவும், பிறகு அதை கைப்பற்றலில் தேடவும். மேலே உள்ள threadFor() அழைப்பு அந்த தேடல் ஆகும். இதை தவறாகப் பெற்றால் graph.invoke தவறான தண்டவாளத்தை மீண்டும் தொடங்கும் அல்லது எதுவும் இல்லை.
ஒத்திசைவு இல்லாத பாதையை கையாளுங்கள், அல்லது எப்போதும் நிறுத்துங்கள்
await_settlement இல் இருந்து நிலைமையால் உண்மையானது என்றால் மட்டுமே வழங்குவதற்கான நிபந்தனை எல்லை. ஒரு கட்டணம் எப்போது நிலை அடையவில்லை என்றால், நூல் முடிவில்லாமல் ஒதுக்கப்படுவதாக இருக்கும். ஒரு காலஅவகாசத்தைச் சேர்க்கவும்: நிலைமையால்=false உடன் பழைய நூல்களை மீண்டும் தொடங்கும் திட்டமிடப்பட்ட சுத்தம், எனவே எல்லை END க்கு வழிசெலுத்துகிறது, அல்லது ஒரு payment.sent-versus-deadline சரிபார்ப்பு. ஒதுக்கப்பட்ட நூல் எதுவும் செலவாகாது, ஆனால் அது தனியாக முடிவடையாது.
தொகைகள் 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.