Add supported payment workflows to LangChain.
ఏ LangChain agent కైనా USDC payments జోడించండి. నిజమైన Python package దానికి కొన్ని పంక్తుల్లోనే wallet tools - send, settle, మరియు read - ఇస్తుంది.
AgentCredia ఒక real Python package, , ను ship చేస్తుంది, ఇది LangChain agent కు native wallet tools ఇస్తుంది: Base పై USDC పంపండి, on-chain proof తో invoice settle చేయండి, మరియు wallets మరియు transactions చదవండి. దాన్ని install చేయండి, set చేయండి, call చేయండి, మరియు tools ను మీ agent కు hand off చేయండి. TypeScript లో? npm adapter లేదు - x402 client ను LangChain.js tool లో wrap చేయండి.
AgentCredia HTTP API పై ఒక బరువైన పొర.
agentcredia-langchain లో ప్రతి సాధనం అధికారిక agentcredia కోర్ SDK పై ఒక సన్నని రాపర్. పునః అమలు చేయబడిన REST లేదా x402 తర్కం లేదు, కీ కస్టడీ లేదు: అడాప్టర్ మీ API కీని బ్యాక్‌ఎండ్‌కు ముందుకు పంపిస్తుంది మరియు తనదైన సీక్రెట్‌ను కలిగి ఉండదు. create_agentcredia_toolset(client) LangChain కు ఐదు సాధనాలను అందిస్తుంది - చెల్లింపు పంపండి, ఇన్వాయిస్‌ను చెల్లించండి, వాలెట్‌ను చదవండి, వాలెట్లను జాబితా చేయండి, లావాదేవీని చదవండి - ప్రతి ఒకటి ఇప్పటికే టైప్ చేయబడింది మరియు స్కోప్ చేయబడింది.
మీరు ఇష్టమైతే కచ్చితమైన API లేదా కోర్ SDKని నేరుగా పిలవవచ్చు. అడాప్టర్ తక్కువ ప్రతిఘటన మార్గం; API ఒప్పందం. agentcredia-langchainని langchain-core పరిధికి పిన్ చేయండి, రెండింటిలో తాజా వాటిని వెంబడించకుండా.
ఒక ఇన్‌స్టాల్. ఒక వాతావరణ మార్పిడి. సిద్ధంగా ఉంది.
ప్యాకేజీకి Python 3.9 లేదా కొత్తది అవసరం. ఇది కోర్ agentcredia SDK మరియు langchain-core ను ఆధారాలుగా తీసుకుంటుంది; జోడించడానికి మరేదీ లేదు.
pip install agentcredia-langchainexport AGENTCREDIA_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
AGENTCREDIA_API_KEY అనేది మీ AgentCredia dashboard నుండి వచ్చిన sk_test_ testnet లేదా sk_live_ mainnet key. Adapter కు అవసరమైన ఏకైక variable ఇదే; ఇది key ను backend కు forward చేస్తుంది, స్వంత secret ఏదీ ఉంచదు. క్రింద చూపిన webhook handler కోసం మీరు AGENTCREDIA_WEBHOOK_SECRET ను కూడా set చేస్తారు, webhook ను create లేదా rotate చేసినప్పుడు dashboard దీన్ని ఒక్కసారి మాత్రమే ఇస్తుంది.
చెల్లింపు మద్దతుతో పనిచేసే LangChain ఏజెంట్.
క్రింద Python లో ఒక పూర్తి LangChain agent ఉంది. create_agentcredia_toolset wallet tools ను return చేస్తుంది, create_react_agent వాటిని ReAct loop లో wire చేస్తుంది, మరియు model prompt నుండి సరైన tool ను picks చేస్తుంది. AGENTCREDIA_API_KEY set చేసి run చేయండి, అప్పుడు agent Base లో USDC ను move చేయగలదు మరియు read చేయగలదు.
from agentcredia import Client from agentcredia_langchain import create_agentcredia_toolset from langchain_openai import ChatOpenAI from langgraph.prebuilt import create_react_agent client = Client() # reads AGENTCREDIA_API_KEY from the environment tools = create_agentcredia_toolset(client) llm = ChatOpenAI(model="gpt-4o") agent = create_react_agent(llm, tools) result = agent.invoke({ "messages": [{ "role": "user", "content": "Pay 0.01 USDC from my agent to 0xRecipient for the dataset.", }], })
Run it with the prompt above and the model picks the send-payment tool, the SDK submits the transfer on Base, and you get a transaction hash back. amount_wei is USDC base units (6 decimals), so 0.01 USDC is the string "10000". A sk_test_ key keeps you on Base Sepolia until you switch to sk_live_. Heads up: payments.create can answer 503 until the chain adapter is wired for your network.
వాడుకరి చెల్లించిన తర్వాత ఏమి జరుగుతుంది.
మీ ఏజెంట్ యొక్క వెబ్హుక్ URL (AgentCredia డాష్‌బోర్డులో సెట్ చేయబడింది) చెల్లింపు స్థిరమైనప్పుడు ఒక POSTను స్వీకరిస్తుంది. వెబ్హుక్ ధృవీకరణ సహాయకుడు Node SDKలో ఉంది, కాబట్టి ఈ హ్యాండ్లర్ TypeScript మీ ఏజెంట్ Python అయినప్పటికీ. కింద సంతకం తనిఖీ చేసే మరియు చెల్లించిన పనిని నడిపించే Express హ్యాండ్లర్ ఉంది. ఏ HTTP ఫ్రేమ్‌వర్క్‌లో అదే నమూనాను ఉపయోగించండి.
import express from "express"; import { webhooks } from "@agentcredia/node"; 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", (req, res) => { const result = webhooks.verify({ headers: req.headers, rawBody: req.body, // Buffer, raw bytes secret: process.env.AGENTCREDIA_WEBHOOK_SECRET!, }); if (!result.ok) return res.status(400).json({ code: result.code }); if (result.eventType === "payment.received") { // USDC landed in your agent wallet - do the paid work } res.status(200).send("ok"); });
webhooks.verify HMAC-SHA256ని స్థిరమైన సమయంలో చేస్తుంది మరియు ఒక వేరుచేసిన యూనియన్‌ను తిరిగి ఇస్తుంది, కాబట్టి మీరు result.ok పై శాఖ చేస్తారు, ప్రయత్నం/పట్టించుకోకుండా మరియు result.eventTypeని చదువుతారు. ముడి శరీరాన్ని చదవండి, పార్స్డ్ కాపీ కాదు: పార్సింగ్ తరువాత మళ్లీ సీరియలైజింగ్ సంతకాన్ని విరిగిస్తుంది. పంపిన ఈవెంట్స్ payment.received, payment.sent, wallet.deployed, మరియు webhook.test; మీ ఏజెంట్కు ఒక ఇన్‌బౌండ్ ఛార్జ్ payment.received.
npm LangChain అడాప్టర్ లేదు. ఇక్కడ నిజమైన వంటకం ఉంది.
పంపిన LangChain అడాప్టర్ కేవలం Python మాత్రమే. npmలో LangChain అడాప్టర్ లేదు. TypeScript LangChain లేదా LangGraph ఏజెంట్ కోసం, మీరు నిజమైన x402 క్లయింట్‌ను LangChain.js సాధనంలో స్వయంగా చుట్టుతారు. ఇది కొన్ని పంక్తులు మాత్రమే, మరియు ఇది ప్రత్యేకమైన అడాప్టర్ అండర్ ది హుడ్ ఏమి చేస్తుందో అదే.
import { createClient } from "@agentcredia/node"; import { createX402Client } from "@agentcredia/x402/client"; import { tool } from "@langchain/core/tools"; import { z } from "zod"; const sdk = createClient({ apiKey: process.env.AGENTCREDIA_API_KEY! }); const fetchWithPay = createX402Client({ sdk }); // There is no npm LangChain adapter. Wrap the x402 client in a LangChain.js tool. export const payAndFetch = tool( async ({ url }) => (await fetchWithPay(url)).text(), { name: "pay_and_fetch", description: "Fetch a URL, answering any x402 payment challenge automatically", schema: z.object({ url: z.string().url() }), }, );
source మరియు testnet examples the Python SDK repo లో ఉన్నాయి; SDK support matrix the docs లో ఉంది. Python smoke example Base Sepolia పై నిజమైన $0.01 USDC transfer ను పంపుతుంది, అదే send-payment action ద్వారా LangChain tool దాన్ని wrap చేస్తుంది.
మొదటి సమీకరణలో బాధించే ఐదు విషయాలు.
ఇవి మా మద్దతు ఇన్బాక్స్ నుండి వస్తాయి. వీటిలో ఏదీ ఒప్పందాన్ని విరమించదు, కానీ ముందుగా వాటి గురించి తెలుసుకోవడం ప్రతి ఒక్కటికి ఒక గంట తల తిరగడం సేవ్ చేస్తుంది.
Amounts USDC base units గా, strings రూపంలో
The payment tools take amount_wei: a string of USDC base units, not a float and not a dollar figure. USDC has 6 decimals, so 0.01 USDC is "10000" and 5 USDC is "5000000". Always pass a string; large integers lose precision as JSON numbers. Send "5.00" and you will either get a validation error or move a millionth of what you meant.
ఇన్వాయిస్ సాధనం కుదిస్తుంది, ఇది సృష్టించదు
agentcredia_settle_invoice ఒక ఉన్న చెల్లింపు అభ్యర్థనను ఆన్-చైన్ సాక్ష్యంతో పరిష్కరిస్తుంది. తాజా ఇన్వాయిస్ లేదా హోస్టెడ్ చెకౌట్ లింక్ను మింట్ చేసే ఎలాంటి టూల్ లేదు: చెల్లింపు అభ్యర్థనలు డాష్‌బోర్డులో సృష్టించబడతాయి, మరియు కోర్ SDK పరిష్కారాన్ని మాత్రమే ప్రదర్శిస్తుంది. ఏజెంట్ తక్షణం చెల్లించగల లింక్ను రూపొందిస్తుందని మీరు ఆశించినట్లయితే, అది ఆకారం కాదు. బ్యాండ్ నుండి అభ్యర్థనను సృష్టించండి, తరువాత ఏజెంట్ దాన్ని పరిష్కరించనివ్వండి.
వెబ్‌హుక్‌లను కచ్చితమైన శరీరానికి ధృవీకరించండి
Webhooks మీ URL కు POST చేస్తాయి, మరియు ఆ URL ను తెలుసుకున్న ఎవ్వరైనా జంక్‌ను POST చేయవచ్చు. మీరు ఒక ఈవెంట్‌ను నమ్మకముందు RAW అభ్యర్థన బైట్స్ పై @agentcredia/node నుండి webhooks.verify ను నడపండి. మొదట JSON ను పార్స్ చేయండి మరియు HMAC సరిపోదు, ఎందుకంటే సంతకం వచ్చిన ఖచ్చితమైన బైట్స్‌ను కవర్ చేస్తుంది. ఇది 300-సెకన్ల రీప్లే విండోతో HMAC-SHA256. దీనిని దాటించడం అత్యంత సాధారణ ఉత్పత్తి మిస్.
send_payment ముందుగా 503ను సమాధానం ఇవ్వవచ్చు
payments.create, agentcredia_send_payment చుట్టినది, డిఫాల్ట్‌గా పునరావృతం చేయదు మరియు మీ నెట్‌వర్క్ కోసం చైన్ అడాప్టర్ కేబుల్ చేయబడేవరకు 503ను తిరిగి ఇవ్వవచ్చు. పొరపాటుపై పునరావృత చక్రంలో టూల్‌ను LLM హామర్ చేయనివ్వవద్దు: ఇది టోకెన్లను కాల్చుతుంది మరియు మీ ఉద్దేశం లాగ్‌ను ముద్దుగా చేస్తుంది. నిర్మిత ఐడెంపోటెన్సీ కీపై నమ్మకం ఉంచండి, విఫలతను ఉపరితలంపై ఉంచండి, ముందుకు సాగండి.
langchain-core వెర్షన్‌ను సరిపోల్చండి
agentcredia-langchain 0.1.x లక్ష్యం langchain-core >=0.2,<0.4. adapter support చేసే దానికంటే కొత్త core లో ఉంటే, రెండింటి latest వెర్షన్లను chase చేయడం కంటే సరిపోయే pair ను pin చేయండి. support matrix docs లో ఉంది.