LlamaIndex ચુકવણી ઇન્ટિગ્રેશન.
કોઈ LlamaIndex પેકેજ નથી, અને તમને એકની જરૂર નથી. વાસ્તવિક blockchain0x ક્લાયન્ટને FunctionTool માં લપેટો અને તમારો એજન્ટ USDC ખસેડી શકે છે અને Base પર એક પેઇડ RAG ક્વેરીને ગેટ કરી શકે છે.
કોઈ LlamaIndex-specific package નથી, અને તમને તેની જરૂર પણ નથી. LlamaIndex સાથે plain function ને tool માં ફેરવે છે, તેથી તમે real 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ને ઇન્સ્ટોલ કરો છો, પછી નીચેનું કાર્ય લખો. કોઈપણ વેક્ટર સ્ટોર સાથે કામ કરે છે - પાઇનકોન, ક્યુડ્રન્ટ, ક્રોમા, વેવિયેટ, LlamaIndex ક્લાઉડ.
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 પર નિયંત્રણ રાખો છો, તો webhook handler ને વધારામાં BLOCKCHAIN0X_WEBHOOK_SECRETની જરૂર પડશે, જે webhook create અથવા rotate કરતાં dashboard એકવાર આપે છે.
એક ફંક્શન જે ચૂકવણી કરે છે, તેને FunctionTool તરીકે લપેટવામાં આવે છે.
નીચે સમગ્ર એકીકરણ છે. send_usdc વાસ્તવિક blockchain0x ક્લાયન્ટને કોલ કરે છે; FunctionTool.from_defaults તેને લપેટે છે, અને FunctionAgent તેને એક callable સાધન તરીકે ઉઠાવે છે. LlamaIndex પ્રકારના સંકેતો અને ડોકસ્ટ્રિંગને વાંચે છે જેથી સ્કીમા બનાવવામાં આવે. તમારી પોતાની QueryEngineToolને યાદીમાં ઉમેરો અને તે જ એજન્ટ RAG પ્રશ્નોનો જવાબ આપી શકે છે.
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 ઇવેન્ટ પોસ્ટ કરે છે. માન્યતા હેલ્પર નોડ 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 પ્રતિસાદ આપો.
તમે લપેટી રહેલા ક્લાયન્ટ ખુલ્લા છે. તેને વાંચો.
ક્લોન કરવા માટે કોઈ 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થી શરૂ કરો, પછી function અપેક્ષા મુજબ કામ કરે ત્યારે sk_live_ પર switch કરો.
પાંચ LlamaIndex-વિશિષ્ટ જાળાઓથી બચવું.
આ અમારા સપોર્ટ ઇનબોક્સમાંથી આવે છે. દરેકને જાણ્યા પછી ઓછામાં ઓછા એક કલાકની ડિબગિંગ બચાવે છે.
કોઈ LlamaIndex પેકેજ નથી - તમે SDK ને લપેટો છો
Blockchain0x LangChain અને CrewAI માટે એડેપ્ટર્સ મોકલે છે અને MCP સર્વર; ત્યાં કોઈ સમર્પિત LlamaIndex પેકેજ નથી. ઉપરનો નુસખો માર્ગ છે: એક સાદી ટાઇપ કરેલ કાર્ય જે વાસ્તવિક blockchain0x ક્લાયન્ટને કોલ કરે છે, જે FunctionTool.from_defaults સાથે લપેટાયેલ છે. LlamaIndex હસ્તાક્ષર અને ડોકસ્ટ્રિંગને વાંચે છે જેથી સ્કીમા બનાવવામાં આવે, તેથી ડોકસ્ટ્રિંગને ચોક્કસ રાખો.
QueryEngineTool ને તમારી જાતે ગેટ કરો - કોઈ સહાયક તે નથી કરે.
પેઇડ-RAG પેટર્ન વાસ્તવિક અને સારું છે, પરંતુ ત્યાં કોઈ paid_query_engine_tool સહાયક નથી. તમે તેને બનાવો: તમારા ક્વેરી ટૂલની કાર્યમાં, તપાસો કે કૉલરએ ચૂકવણી કરી છે કે નહીં (તમારી પોતાની દુકાન, નીચેના વેબહૂક દ્વારા અપડેટ થયેલ) અને જો તેમણે કરી છે તો જ પુનઃપ્રાપ્તિ ચલાવો, અન્યથા એક કિંમત પાછી આપો. તે થોડા પંક્તિઓ છે, અને તમે ગેટિંગ નીતિ પર નિયંત્રણ રાખો છો.
રકમ USDC આધાર એકમો છે, સ્ટ્રિંગ્સ તરીકે
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 એજન્ટો એ અસિંક-પ્રથમ છે - એજન્ટ.run(...)ની રાહ જુઓ. તમારા ટૂલની અંદર blockchain0x ક્લાયન્ટ કોલ સમકાલીન છે, જે એક જ ઝડપી ચુકવણી માટે યોગ્ય છે પરંતુ લોડ હેઠળ લૂપને અવરોધિત કરે છે. જો તમે ઘણા સમકાલીન પ્રશ્નો સેવા આપી રહ્યા છો, તો SDK કોલને asyncio.to_thread સાથે લપેટો જેથી ઇવેન્ટ લૂપ પ્રતિસાદી રહે.
send_payment વહેલા 503 જવાબ આપી શકે છે
payments.create ડિફોલ્ટ દ્વારા પુનરાવૃત્ત નથી કરે અને તમારા નેટવર્ક માટે ચેઇન એડેપ્ટર વાયર કરવામાં આવે ત્યાં સુધી 503 પાછું આપી શકે છે. તમારા ટૂલ ફંક્શનની અંદર ભૂલને પકડો અને મોડેલ કાર્ય કરી શકે તેવા સ્પષ્ટ સંદેશાને પાછું આપો, એજન્ટને લૂપ પર મૂકવા બદલ. આપોઆપ મિન્ટ કરેલ idempotency કીનો અર્થ એ છે કે મેન્યુઅલ પુનરાવૃત્તિ ડબલ-ચુકવણી નહીં કરે.