LlamaIndex പേയ്മെന്റ് ഇന്റഗ്രേഷൻ.
LlamaIndex പാക്കേജ് ഇല്ല, നിങ്ങൾക്ക് ഒന്നും ആവശ്യമില്ല. യഥാർത്ഥ blockchain0x ക്ലയന്റിനെ FunctionTool-ൽ മൂടുക, നിങ്ങളുടെ ഏജന്റ് USDC നീക്കാൻ കഴിയും, കൂടാതെ Base-ൽ ഒരു പണമടച്ച RAG ചോദ്യം ഗേറ്റ് ചെയ്യാൻ കഴിയും.
LlamaIndex-യ്ക്ക് പ്രത്യേക 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 വിളികളിൽ യഥാർത്ഥ പണം ചെലവഴിക്കുന്നു. സൗജന്യമായ അനന്തമായ ആക്സസ് ബജറ്റ് കത്തിക്കുന്നു; ഓരോ-query ബില്ലിംഗ് ചെലവിന്റെ രൂപം അനുയോജ്യമാണ്.
ഇതിന് അയച്ച സഹായകമില്ല, നിങ്ങൾക്ക് ഒന്നും ആവശ്യമില്ല. നിങ്ങൾ തന്നെ ഗേറ്റ് ചെയ്യുന്നു: നിങ്ങളുടെ 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 കീ ആണ്; client അതിനെ environment-ൽ നിന്ന് വായിക്കുന്നു. paid queries നിയന്ത്രിക്കുന്നുവെങ്കിൽ, webhook handler-ിന് കൂടി BLOCKCHAIN0X_WEBHOOK_SECRET ആവശ്യമാണ്, ഇത് ഒരു webhook create ചെയ്യുമ്പോഴോ rotate ചെയ്യുമ്പോഴോ dashboard ഒരിക്കൽ return ചെയ്യും.
ഒരു ഫംഗ്ഷൻ, FunctionTool ആയി ചുറ്റിയിരിക്കുന്നു.
താഴെ മുഴവൻ സംയോജനം ആണ്. send_usdc യഥാർത്ഥ blockchain0x ക്ലയന്റ് വിളിക്കുന്നു; FunctionTool.from_defaults ഇത് ചുറ്റിക്കൊള്ളുന്നു, FunctionAgent ഇത് വിളിക്കാവുന്ന ഉപകരണമായി picks ചെയ്യുന്നു. 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 ഇവന്റ് POST ചെയ്യുന്നു. verify സഹായകം 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) enqueue ചെയ്യുക, ഹാൻഡ്ലർ തടയുന്നതിന് പകരം ഉടൻ 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 ൽ രേഖപ്പെടുത്തിയിരിക്കുന്നു. Base Sepolia-യിൽ sk_test_ key ഉപയോഗിച്ച് ആരംഭിക്കുക, തുടർന്ന് function നിങ്ങൾ പ്രതീക്ഷിക്കുന്നതു പോലെ പ്രവർത്തിക്കുമ്പോൾ sk_live_ ആയി മാറുക.
എടുപ്പിക്കേണ്ട അഞ്ചു LlamaIndex-നിഷ്ഠമായ തട്ടിപ്പുകൾ.
ഇവ നമ്മുടെ പിന്തുണ ഇൻബോക്സിൽ നിന്നാണ്. നിങ്ങൾക്ക് ഇതിനെക്കുറിച്ച് അറിയുമ്പോൾ ഓരോന്നും കുറഞ്ഞത് ഒരു മണിക്കൂർ ഡീബഗിംഗ് സംരക്ഷിക്കുന്നു.
LlamaIndex പാക്കേജ് ഇല്ല - നിങ്ങൾ SDK-നെ മൂടുന്നു
Blockchain0x LangChain, CrewAI, MCP സെർവറിന് അഡാപ്റ്ററുകൾ അയക്കുന്നു; പ്രത്യേക LlamaIndex പാക്കേജ് ഇല്ല. മുകളിൽ നൽകിയ റെസിപ്പി വഴി: യഥാർത്ഥ blockchain0x ക്ലയന്റ് വിളിക്കുന്ന ഒരു സാധാരണ typed ഫംഗ്ഷൻ, 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 ഏജന്റുകൾ അസിങ്ക്-പ്രഥമമാണ് - await agent.run(...). നിങ്ങളുടെ ഉപകരണത്തിനുള്ള blockchain0x ക്ലയന്റ് വിളി സിങ്ക്രണസ് ആണ്, ഇത് ഒരു ഏക വേഗത്തിലുള്ള പണമിടപാടിന് ശരിയാണ്, പക്ഷേ ലോഡിൽ ലൂപ്പ് തടയുന്നു. നിങ്ങൾക്ക് നിരവധി സമകാലിക അഭ്യർത്ഥനകൾ സേവനം നൽകുന്നുവെങ്കിൽ, SDK വിളി asyncio.to_thread-ൽ ചുറ്റികൊടുത്താൽ ഇവന്റ് ലൂപ്പ് പ്രതികരണശീലമായി തുടരുന്നു.
send_payment തുടക്കത്തിൽ 503 മറുപടി നൽകാം
payments.create ഡിഫോൾട്ടായി വീണ്ടും ശ്രമിക്കില്ല, കൂടാതെ നിങ്ങളുടെ network-നായി chain adapter ബന്ധിപ്പിക്കുന്നതുവരെ 503 തിരികെ നൽകാം. agent loop ചെയ്യാൻ വിടാതെ, നിങ്ങളുടെ tool function-ൽ തന്നെ error പിടിച്ച് model പ്രവർത്തിക്കാനാവുന്ന വ്യക്തമായ സന്ദേശം മടക്കുക. സ്വയമേവ സൃഷ്ടിച്ച idempotency key ഉള്ളതിനാൽ മാനുവൽ retry double-pay ഉണ്ടാക്കില്ല.