LlamaIndex చెల్లింపు ఇంటిగ్రేషన్.
LlamaIndex ప్యాకేజీ లేదు, మరియు మీకు ఒకటి అవసరం లేదు. నిజమైన blockchain0x క్లయింట్ను FunctionToolలో చుట్టండి మరియు మీ ఏజెంట్ USDCని కదిలించగలదు మరియు Baseలో చెల్లించిన RAG ప్రశ్నను గేట్ చేయగలదు.
LlamaIndex కోసం ప్రత్యేక package లేదు, మీకు అది అవసరమూ లేదు. LlamaIndex తో సాధారణ function ను tool గా మారుస్తుంది, కాబట్టి మీరు నిజమైన Python client ను ఒక function లో wrap చేసి, దాన్ని లేదా లో చేర్చుతారు. Agent USDC పంపగలదు, invoices settle చేయగలదు, wallets చదవగలదు. ప్రతి RAG query కి charge చేయాలంటే, మీ స్వంత QueryEngineTool ను అదే విధంగా gate చేయండి. Payments Base పై settle అవుతాయి.
RAG ప్రశ్నలు ఖరీదైనవి. ప్రతి ప్రశ్నకు ఛార్జ్ చేయడం ఆర్థికాలను పనిచేయిస్తుంది.
LlamaIndex యొక్క శక్తి పునఃప్రాప్తి-వృద్ధి ఉత్పత్తి: మీకు స్వంత డాక్యుమెంట్లపై (మీ కంపెనీ డాక్స్, పరిశోధన డేటాసెట్, చట్టపరమైన కాపీ) వెక్టర్ సూచిక ఉంది, మరియు ఏజెంట్ సంబంధిత భాగాలను పునఃప్రాప్తి చేసి సంక్షిప్తంగా సమాధానం ఇస్తుంది. ప్రతి ప్రశ్న ఎంబెడ్డింగ్స్, LLM టోకెన్లలో నిజమైన డబ్బు ఖర్చు చేస్తుంది మరియు తరచుగా మూడవ పక్ష API కాల్స్. ఉచిత అపరిమిత యాక్సెస్ బడ్జెట్ ను కాల్చుతుంది; ప్రతి-ప్రశ్న బిల్లింగ్ ఖర్చు ఆకారానికి సరిపోతుంది.
దీనికి పంపిన సహాయకుడు లేదు, మరియు మీకు ఒకటి అవసరం లేదు. మీరు దీన్ని స్వయంగా గేట్ చేస్తారు: మీ QueryEngineTool యొక్క ఫంక్షన్లో, కాలర్ చెల్లించిందో లేదో తనిఖీ చేయండి (మీ స్వంత జెండా, చెల్లింపు వెబ్హుక్ ద్వారా తిరిగి తిప్పబడింది) మరియు లేదా పునరుద్ధరణను నడపండి లేదా ధరను తిరిగి ఇవ్వండి. వాలెట్ ఫంక్షన్ మరియు గేటింగ్ రెండూ నిజమైన blockchain0x క్లయింట్పై కొన్ని పంక్తులు, ఇది విధానాన్ని ఉంచుతుంది - ప్రతి ప్రశ్న, ప్రతి సెషన్, ఉచిత స్థాయి తరువాత చెల్లింపు - పూర్తిగా మీ చేతుల్లో.
LlamaIndex మరియు కోర్ SDKని ఇన్స్టాల్ చేయండి. ఒక వాతావరణ మార్పిడి.
చేర్చడానికి blockchain0x LlamaIndex ప్యాకేజీ లేదు. మీరు LlamaIndexని (Python 3.10+, ఆధునిక FunctionAgent / ReActAgent / Workflows APIs) మరియు నిజమైన blockchain0x కోర్ SDKని ఇన్స్టాల్ చేస్తారు, తరువాత క్రింద ఫంక్షన్ను రాస్తారు. ఏ వెక్టర్ స్టోర్తో పాటు పనిచేస్తుంది - Pinecone, Qdrant, Chroma, Weaviate, LlamaIndex Cloud.
pip install llama-index blockchain0xexport BLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
BLOCKCHAIN0X_API_KEY అనేది మీ dashboard నుండి వచ్చిన sk_test_ testnet లేదా sk_live_ mainnet key; client దాన్ని environment నుండి చదువుతుంది. మీరు paid queries ను gate చేస్తే, webhook handler కు అదనంగా BLOCKCHAIN0X_WEBHOOK_SECRET అవసరం, webhook ను create లేదా rotate చేసినప్పుడు dashboard దీన్ని ఒక్కసారి మాత్రమే ఇస్తుంది.
చెల్లించే ఒక ఫంక్షన్, FunctionToolగా కప్పబడింది.
ఇది మొత్తం integration. send_usdc real blockchain0x client ను call చేస్తుంది; FunctionTool.from_defaults దాన్ని wrap చేస్తుంది, మరియు FunctionAgent దాన్ని callable tool గా picks up చేస్తుంది. LlamaIndex schema build చేయడానికి type hints మరియు docstring ను reads చేస్తుంది. మీ own QueryEngineTool ను list కు add చేయండి, అప్పుడు అదే agent RAG queries కి కూడా answer చేయగలదు.
from llama_index.core.tools import FunctionTool from llama_index.core.agent.workflow import FunctionAgent from llama_index.llms.openai import OpenAI from blockchain0x import Client blockchain0x = Client() # reads BLOCKCHAIN0X_API_KEY from the environment def send_usdc(agent_id: str, to: str, amount_wei: str) -> str: """Send a USDC payment from an agent wallet. amount_wei is USDC base units (6 decimals), so "10000" is 0.01 USDC. """ return str( blockchain0x.payments.create(body={"agentId": agent_id, "to": to, "amountWei": amount_wei}) ) # Wrap the plain function as a LlamaIndex tool. No dedicated package needed. pay_tool = FunctionTool.from_defaults(fn=send_usdc) agent = FunctionAgent( tools=[pay_tool], # plus your own QueryEngineTool over a RAG index llm=OpenAI(model="gpt-4o"), system_prompt="You pay vendor invoices in USDC within owner-set limits.", ) response = await agent.run( "Pay 0.01 USDC from agent agt_123 to 0xVendor for the dataset." )
When the agent decides to pay, it calls send_usdc, the SDK submits the transfer, and you get a transaction hash back. amount_wei is base units, so 0.01 USDC is "10000". A sk_test_ key keeps it on Base Sepolia until you switch to sk_live_. To charge for a query instead, put the same paid check at the top of your QueryEngineTool's function.
వెబ్హుక్ ల్యాండైనప్పుడు చెల్లించిన జెండాను మార్చండి.
ఒక చెల్లింపు స్థిరమైనప్పుడు, Blockchain0x మీ వెబ్హుక్ URL కు సంతకం చేసిన payment.received ఈవెంట్ను POST చేస్తుంది. ధృవీకరణ సహాయాన్ని Node SDK లో పంపిస్తారు; ఒక Python సేవ డాక్యుమెంటెడ్ HMAC కు చేతితో ధృవీకరించుతుంది. కాలర్ చెల్లించినట్లు మీ స్వంత స్టోర్లో గుర్తించండి, మరియు మీ గేటెడ్ క్వెరీ టూల్ తదుపరి కాల్ను అనుమతిస్తుంది. క్రింద FastAPI ఉదాహరణ.
import hmac, hashlib, os, time from fastapi import FastAPI, Request, HTTPException app = FastAPI() SECRET = os.environ["BLOCKCHAIN0X_WEBHOOK_SECRET"].encode() @app.post("/webhooks/payment") async def receive(request: Request): raw = await request.body() # RAW bytes - do not parse first sig = request.headers.get("X-Blockchain0x-Signature", "") ts = request.headers.get("X-Blockchain0x-Timestamp", "") parts = dict(p.split("=", 1) for p in sig.split(",") if "=" in p) t, v1 = parts.get("t", ts), parts.get("v1", sig) want = hmac.new(SECRET, t.encode() + b"." + raw, hashlib.sha256).hexdigest() if not hmac.compare_digest(want, v1) or abs(time.time() - int(t)) > 300: raise HTTPException(status_code=401) if request.headers.get("X-Blockchain0x-Event-Type") == "payment.received": await trigger_followup() # USDC landed - serve the paid query return {"ok": True}
అల్గోరిథం t.rawBody అనే స్ట్రింగ్పై HMAC-SHA256, స్థిర-సమయాన్ని పోల్చడం, మరియు 300-సెకన్ల రీప్లే విండో. సంతకం కవర్ చేసే బైట్స్ను మార్చడం వల్ల await request.body() ద్వారా కచ్చితమైన శరీరాన్ని చదవండి, ఎప్పుడూ request.json() మళ్లీ సీరియలైజ్ చేయకండి. పంపిన ఈవెంట్లు payment.received, payment.sent, wallet.deployed, మరియు webhook.test. భారీ ఫాలో-అప్ పనికి, ఒక ఉద్యోగాన్ని ఎన్క్యూ చేయండి (Celery, arq) మరియు హ్యాండ్లర్ను బ్లాక్ చేయకుండా వెంటనే 200 కి స్పందించండి.
మీరు ముడివేస్తున్న క్లయింట్ ఓపెన్ ఉంది. దీన్ని చదవండి.
clone చేయడానికి ప్రత్యేక LlamaIndex starter package లేదు - పై recipe నే integration. blockchain0x SDKs GitHub లో open source గా ఉన్నాయి; ఈ recipe Python SDK (blockchain0x-python) ను wrap చేస్తుంది, పూర్తి method surface docs లో ఉంది. function bodies కోసం reference గా చదవండి.
github.com/tosh-labs/blockchain0x-pythonపూర్తి SDK method surface మరియు scopes the docs లో documented గా ఉన్నాయి. Base Sepolia పై sk_test_ key తో start చేయండి, తర్వాత function మీరు ఆశించినట్లు పనిచేసినప్పుడు sk_live_ కి switch చేయండి.
గమనించాల్సిన ఐదు LlamaIndex-సంబంధిత చిక్కులు.
ఇవి మా మద్దతు ఇన్బాక్స్ నుండి వస్తాయి. మీరు దీని గురించి తెలిసినప్పుడు ప్రతి ఒక్కటి కనీసం ఒక గంట డిబగ్గింగ్ను సేవ్ చేస్తుంది.
LlamaIndex ప్యాకేజీ లేదు - మీరు SDKని చుట్టండి
Blockchain0x LangChain మరియు CrewAI కోసం అడాప్టర్లు మరియు MCP సర్వర్ను పంపిస్తుంది; ప్రత్యేకమైన LlamaIndex ప్యాకేజీ లేదు. పై వంటకం మార్గం: వాస్తవ blockchain0x క్లయింట్ను కాల్ చేసే సాధారణ టైప్డ్ ఫంక్షన్, FunctionTool.from_defaults తో చుట్టబడింది. LlamaIndex సంతకం మరియు డాక్స్ట్రింగ్ను చదివి స్కీమాను నిర్మిస్తుంది, కాబట్టి డాక్స్ట్రింగ్ ఖచ్చితంగా ఉంచండి.
మీరు ఒక QueryEngineToolని గేట్ చేయండి - ఎలాంటి సహాయకుడు చేయదు
చెల్లించిన-RAG నమూనా నిజంగా మంచిది, కానీ paid_query_engine_tool సహాయకారుడు లేదు. మీరు దీన్ని నిర్మిస్తారు: మీ క్వెరీ సాధనంలోని ఫంక్షన్లో, కాలర్ చెల్లించిందో లేదో తనిఖీ చేయండి (మీ స్వంత స్టోర్, క్రింద ఉన్న వెబ్హుక్ ద్వారా నవీకరించబడింది) మరియు వారు చెల్లించినట్లయితే మాత్రమే పునరావృతాన్ని నడపండి, లేకపోతే ధరను తిరిగి ఇవ్వండి. ఇది కొన్ని పంక్తులు, మరియు మీరు గేటింగ్ విధానాన్ని నియంత్రించుకుంటారు.
Amounts USDC base units గా, strings రూపంలో
payments.create takes amountWei: a string of USDC base units, not a float. USDC has 6 decimals, so 0.01 USDC is "10000" and 5 USDC is "5000000". Type the tool argument as str. LlamaIndex passes tool args through pydantic, which will happily coerce a float and lose precision, so keep it a string end to end.
FunctionAgent.run అసంక్రోనస్; SDK కాల్ సమకాలికం
LlamaIndex ఏజెంట్లు అసంక్రోనస్-ముందు - await agent.run(...). మీ టూల్ లో blockchain0x క్లయింట్ కాల్ సమకాలికంగా ఉంది, ఇది ఒకే తక్షణ చెల్లింపుకు సరైనది కానీ లోడ్ కింద లూప్ ను బ్లాక్ చేస్తుంది. మీరు అనేక సమకాలీన ప్రశ్నలను అందిస్తున్నట్లయితే, SDK కాల్ ను asyncio.to_thread తో చుట్టండి కాబట్టి ఈవెంట్ లూప్ స్పందనాత్మకంగా ఉంటుంది.
send_payment ముందుగా 503ను సమాధానం ఇవ్వవచ్చు
payments.create డిఫాల్ట్గా పునరావృతం చేయదు మరియు మీ నెట్వర్క్ కోసం చైన్ అడాప్టర్ కేబుల్ చేయబడేవరకు 503ను తిరిగి ఇవ్వవచ్చు. మీ టూల్ ఫంక్షన్లో పొరపాటును పట్టుకోండి మరియు మోడల్ చర్య తీసుకునే స్పష్టమైన సందేశాన్ని తిరిగి ఇవ్వండి, ఏజెంట్ చక్రం చేయకుండా. ఆటో-మింటెడ్ ఐడెంపోటెన్సీ కీ ఒక మాన్యువల్ రిట్రై డబుల్-చెల్లించదు.