ప్రధాన కంటెంట్‌కు దాటవేయండి
LANGGRAPH ఇంటిగ్రేషన్

LangGraph చెల్లింపు ఇంటిగ్రేషన్.

LangGraph ప్యాకేజీ అవసరం లేదు. ఒక సాధారణ నోడ్ నిజమైన blockchain0x క్లయింట్ ను కాల్ చేస్తుంది, interrupt() చెల్లింపు వెబ్‌హుక్ ల్యాండింగ్ అయ్యేవరకు నిలిపివేస్తుంది, మరియు గ్రాఫ్ పునరుద్ధరించబడుతుంది - నడుస్తున్నప్పుడు మన్నికైనది.

చిన్న సమాధానం

LangGraph కోసం ప్రత్యేక package లేదు, మీకు అది అవసరమూ లేదు. మీ లోని సాధారణ node నిజమైన client ను పిలుస్తుంది, ఒక payment webhook వచ్చేవరకు graph ను నిలిపివేస్తుంది, ఆపై handler LangGraph యొక్క స్వంత + తో దాన్ని తిరిగి కొనసాగిస్తుంది. Payments Base పై settle అవుతాయి.

LANGGRAPH ఈ నమూనాకు ఎందుకు సరిపోతుంది

దృఢమైన అమలు చెల్లింపు తర్వాత పునఃప్రారంభం నమూనాను సహజంగా చేస్తుంది.

ఏజెంట్-చాలించిన చెల్లింపుల కఠినమైన భాగం అసింక్ గ్యాప్: మీరు చెల్లింపును అభ్యర్థిస్తారు, కొనుగోలుదారు కొన్ని నిమిషాల తర్వాత (లేదా ఎప్పుడూ కాదు) చెల్లిస్తాడు, మరియు మీరు మీరు ఉన్న స్థితిని కోల్పోకుండా పని కొనసాగించాలి. ఎక్కువ మంది ఏజెంట్ ఫ్రేమ్‌వర్క్‌లు ఈ గ్యాప్‌ను బ్రిడ్జ్ చేయడానికి ఉద్యోగ క్యూకు + మాన్యువల్ స్టేట్-స్టోర్‌పై ఆధారపడి ఉంటాయి. LangGraph ఇప్పటికే ప్రాథమికంగా నిర్మించబడింది: interrupt() ఒక నోడ్లో ఒక గ్రాఫ్‌ను నిలిపివేస్తుంది మరియు ఒక చెక్‌పాయింటర్ రాష్ట్రాన్ని డిస్క్‌కు నిలుపుతుంది. పునరావృతం ఒక కాల్.

ఈ recipe దాన్ని ఎలాంటి special machinery లేకుండా ఉపయోగిస్తుంది. సాధారణ pay node blockchain0x.payments.create ను call చేస్తుంది. await_settlement node suspend చేయడానికి interrupt() ను call చేస్తుంది, మరియు checkpointer state ను persist చేస్తుంది. webhook handler signature ను verify చేసి, matching thread పై graph.updateState తో settled ను set చేస్తుంది, తర్వాత interrupt నుండి కొనసాగించడానికి graph.invoke ను call చేస్తుంది. graph అది ఆగిన exact చోట నుంచే తిరిగి ప్రారంభమవుతుంది, ముందరి nodes నుండి వచ్చిన ఏదైనా LLM context సహా - ఇవన్నీ LangGraph own 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 లో నడిస్తే, handler suspended thread ను కనుగొనడానికి రెండింటికీ ఒకే checkpointer (ఉదా. shared Postgres) అవసరం.

పూర్తి గ్రాఫ్ ఉదాహరణ

మూడు-నోడ్ గ్రాఫ్: చెల్లించు, నిలిపివేయు, అందించు.

క్రింద typed State తో ఒక పూర్తి LangGraph workflow ఉంది, real blockchain0x.payments.create ను call చేసే pay node, interrupt-based await_settlement node, మరియు chain payment move అయినట్లు confirm చేసిన తర్వాత dependent work ను run చేసే deliver node ఉన్నాయి.

GRAPH.TS
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.

WEBHOOK.TS
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.

మూలం మరియు డాక్స్

మీరు ముడివేస్తున్న క్లయింట్ ఓపెన్ ఉంది. దీన్ని చదవండి.

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 లో documented గా ఉన్నాయి. Base Sepolia పై sk_test_ key తో start చేయండి, తర్వాత graph మీరు ఆశించిన విధంగా resume అయినప్పుడు sk_live_ కి switch చేయండి.

సాధారణ పిట్ఫాల్స్

గమనించాల్సిన ఐదు LangGraph-సంబంధిత చిక్కులు.

LangGraph యొక్క దృఢ-అమలు మోడల్ శక్తివంతమైనది కానీ చెక్‌పాయింట్లు, అంతరాయాలు మరియు రాష్ట్ర నవీకరణల చుట్టూ దాని స్వంత పాదాలు ఉన్నాయి.

PITFALL 1

LangGraph ప్యాకేజీ లేదు - ఒక సాధారణ నోడ్ SDKని కాల్ చేస్తుంది

Blockchain0x LangChain మరియు CrewAI కోసం అడాప్టర్లు మరియు MCP సర్వర్‌ను పంపిస్తుంది; npm లేదా pip లో ప్రత్యేకమైన LangGraph ప్యాకేజీ లేదు. పై వంటకం మార్గం: సాధారణ గ్రాఫ్ నోడ్ వాస్తవ @blockchain0x/node క్లయింట్‌ను కాల్ చేస్తుంది, మరియు మీరు LangGraph యొక్క స్వంత graph.updateState + graph.invoke తో కొనసాగిస్తారు. ప్రత్యేకమైన పేమెంట్-నోడ్ తరగతి మరియు దిగుమతి చేసుకోవడానికి సహాయకుడు లేదు - అవి ఎప్పుడూ ఉండలేదు.

PITFALL 2

చెక్‌పాయింటర్ లేదు

LangGraph యొక్క interrupt() కేవలం గ్రాఫ్‌లో చెక్‌పాయింటర్ ఉంటే మాత్రమే పనిచేస్తుంది. ఒకటి లేకపోతే, మీ ప్రక్రియ బయటకు వెళ్లినప్పుడు రాష్ట్రం ఆవిరి అవుతుంది మరియు వెబ్‌హుక్ హ్యాండ్లర్‌కు పునరుద్ధరించడానికి ఎలాంటి థ్రెడ్ ఉండదు. అభివృద్ధి కోసం MemorySaverని ఉపయోగించండి మరియు ఉత్పత్తిలో SqliteSaver లేదా PostgresSaverని ఉపయోగించండి. మీ గ్రాఫ్ మరియు వెబ్‌హుక్ హ్యాండ్లర్ వేర్వేరు ప్రక్రియల్లో నడిస్తే, అవి ఒకే చెక్‌పాయింటర్‌ను పంచుకోవాలి (ఉదాహరణకు ఒక Postgres) కాబట్టి హ్యాండ్లర్ నిలిపివేయబడిన థ్రెడ్‌ను కనుగొనగలదు.

PITFALL 3

సరైన థ్రెడ్ కు వెబ్‌హుక్‌ను మ్యాప్ చేయడం మీ పని

వెబ్‌హుక్ మీకు ఒక చెల్లింపు స్థిరమైనదని చెబుతుంది; ఇది మీ LangGraph thread_idని తెలియదు. మీ స్వంత మ్యాపింగ్‌ను ఉంచండి - మీరు గ్రాఫ్‌ను ప్రారంభించినప్పుడు, ఏజెంట్, స్వీకర్త లేదా మీరు సెట్ చేసిన ఐడెంపొటెన్సీ కీ ద్వారా కీ చేయబడిన thread_idని నిల్వ చేయండి, తరువాత దానిని హ్యాండ్లర్‌లో చూడండి. పై threadFor() కాల్ ఆ లుకప్. ఇది తప్పు అయితే graph.invoke తప్పు థ్రెడ్‌ను లేదా ఏదీ కాదు తిరిగి ప్రారంభిస్తుంది.

PITFALL 4

సమాధానంలేని మార్గాన్ని నిర్వహించండి, లేదా శాశ్వతంగా నిలిపివేయండి

await_settlement నుండి కండిషనల్ ఎడ్జ్ కుదిరినప్పుడు మాత్రమే డెలివరీని అందించడానికి మార్గాలను సూచిస్తుంది. ఒక చెల్లింపు ఎప్పుడూ చేరకపోతే, థ్రెడ్ నిరంతరం సస్పెండ్ అవుతుంది. ఒక టైమౌట్ జోడించండి: కుదిరిన=false తో పాత థ్రెడ్‌లను పునరారంభించే షెడ్యూల్ చేసిన స్వీప్ కాబట్టి ఎడ్జ్ END కు మార్గాలను సూచిస్తుంది, లేదా చెల్లింపు.sent-versus-deadline తనిఖీ. ఒక సస్పెండెడ్ థ్రెడ్ ఎలాంటి ఖర్చు ఉండదు, కానీ అది తనదైన విధంగా ఎప్పుడూ ముగించదు.

PITFALL 5

Amounts USDC base units గా, strings రూపంలో

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.

సాధారణంగా అడిగే

మూడు LangGraph-స్పెసిఫిక్ ప్రశ్నలు.

npm లేదా pipలో LangGraph ప్యాకేజీ ఉందా?

లేదు. LangGraph ఇప్పటికే మీకు అన్ని విషయాలను ఇస్తుంది: ఒక నోడ్ కేవలం ఒక ఫంక్షన్, interrupt() నిలిపివేస్తుంది, ఒక చెక్‌పాయింటర్ నిలుస్తుంది, మరియు graph.updateState + graph.invoke పునరుద్ధరించబడుతుంది. కాబట్టి నిజమైన మార్గం @blockchain0x/node క్లయింట్ (లేదా Python blockchain0x క్లయింట్) ను కాల్ చేసే సాధారణ నోడ్. పంపబడిన ఏకైక ఫ్రేమ్‌వర్క్ ప్యాకేజీలు blockchain0x-langchain మరియు blockchain0x-crewai (రెండు Python) మరియు @blockchain0x/mcp సర్వర్.

నేను Python LangGraph లో కూడా ఇది చేయగలనా?

అవును, అదే recipe. Python LangGraph లో కూడా అదే primitives ఉంటాయి - ఒక function node, interrupt(), ఒక checkpointer, మరియు కొనసాగించడానికి Command(resume=...) లేదా update_state + invoke. మీ node Python blockchain0x client (blockchain0x.payments.create(...)) ను పిలుస్తుంది, మరియు మీ webhook handler signature ను verify చేసి thread ను resume చేస్తుంది. langgraph మరియు blockchain0x తప్ప ఇంకే pip package ని install చేయాల్సిన అవసరం లేదు; graph definition TypeScript version కు దాదాపు సమానం.

ఇది LangGraph ప్లాట్‌ఫామ్ మరియు హ్యూమన్-ఇన్-ది-లూప్ నోడ్స్ తో పనిచేస్తుందా?

అవును. రెసిపీ సాధారణ LangGraph, కాబట్టి ఇది LangGraph ప్లాట్‌ఫారమ్‌లో అదే విధంగా పనిచేస్తుంది - మీ Blockchain0x వెబ్‌హుక్‌ను అమలుకు సూచించండి మరియు అక్కడ థ్రెడ్‌ను పునరుద్ధరించండి. interrupt() ఒక గ్రాఫ్‌లో అనేక విఘటన పాయింట్లను కూడా మద్దతిస్తుంది: వెబ్‌హుక్ ద్వారా పునరుద్ధరించబడిన చెల్లింపు విఘటన మరియు UI చర్య ద్వారా పునరుద్ధరించబడిన మానవ సమీక్ష విఘటన ఒకే సమయంలో ఉండవచ్చు, ప్రతి పునరుద్ధరణ రాష్ట్రంలో తన స్వంత ఫీల్డ్‌ను నవీకరించినంత కాలం. గ్రాఫ్ వాటిని క్రమంలో మార్గం చూపిస్తుంది.
అన్ని ఇంటిగ్రేషన్లు ధర

మీ గ్రాఫ్‌కు స్థిరమైన చెల్లింపులను జోడించండి.

చెల్లింపుపై నిలిపివేయండి, వెబ్‌హుక్‌పై పునరుద్ధరించండి, అన్నీ LangGraph యొక్క స్వంత APIs తో. ప్రారంభించడానికి ఉచితం.