LlamaIndex ਭੁਗਤਾਨ ਇੰਟੀਗ੍ਰੇਸ਼ਨ।
ਕੋਈ LlamaIndex ਪੈਕੇਜ ਨਹੀਂ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇੱਕ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਅਸਲੀ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਇੱਕ FunctionTool ਵਿੱਚ ਲਪੇਟੋ ਅਤੇ ਤੁਹਾਡਾ ਏਜੰਟ USDC ਨੂੰ ਚਲਾ ਸਕਦਾ ਹੈ ਅਤੇ ਬੇਸ 'ਤੇ ਇੱਕ ਭੁਗਤਾਨ ਕੀਤੀ RAG ਪੁੱਛਗਿੱਛ ਨੂੰ ਗੇਟ ਕਰ ਸਕਦਾ ਹੈ।
LlamaIndex-specific ਕੋਈ package ਨਹੀਂ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇਸਦੀ ਲੋੜ ਵੀ ਨਹੀਂ। LlamaIndex ਨਾਲ ਇੱਕ plain function ਨੂੰ tool ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ, ਇਸ ਲਈ ਤੁਸੀਂ ਅਸਲੀ Python client ਨੂੰ ਇੱਕ function ਵਿੱਚ wrap ਕਰਦੇ ਹੋ ਅਤੇ ਉਸਨੂੰ ਜਾਂ ਵਿੱਚ add ਕਰਦੇ ਹੋ। 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 ਕੋਰ ਐਸਡੀਕੇ ਨੂੰ ਇੰਸਟਾਲ ਕਰਦੇ ਹੋ, ਫਿਰ ਹੇਠਾਂ ਦਿੱਤੀ ਫੰਕਸ਼ਨ ਲਿਖਦੇ ਹੋ। ਇਹ ਕਿਸੇ ਵੀ ਵੈਕਟਰ ਸਟੋਰ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ - 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 ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜੋ dashboard webhook create ਜਾਂ rotate ਕਰਨ ਸਮੇਂ ਇਕ ਵਾਰ ਦਿੰਦਾ ਹੈ।
ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ, ਇੱਕ FunctionTool ਵਜੋਂ ਲਪੇਟਿਆ ਗਿਆ.
ਹੇਠਾਂ ਪੂਰੀ ਇੰਟਿਗ੍ਰੇਸ਼ਨ ਹੈ। send_usdc ਅਸਲ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ; FunctionTool.from_defaults ਇਸਨੂੰ ਲਪੇਟਦਾ ਹੈ, ਅਤੇ FunctionAgent ਇਸਨੂੰ ਇੱਕ ਕਾਲ ਕਰਨ ਯੋਗ ਟੂਲ ਵਜੋਂ ਚੁਣਦਾ ਹੈ। 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.
ਜਦੋਂ ਵੈਬਹੂਕ ਲੈਂਡ ਕਰਦਾ ਹੈ ਤਾਂ ਭੁਗਤਾਨ ਕੀਤਾ ਗਿਆ ਝੰਡਾ ਫਲਿਪ ਕਰੋ।
ਜਦੋਂ payment settle ਹੁੰਦੀ ਹੈ, Blockchain0x ਤੁਹਾਡੇ webhook URL 'ਤੇ ਇੱਕ signed payment.received event POST ਕਰਦਾ ਹੈ। verify helper Node SDK ਵਿੱਚ ship ਹੁੰਦਾ ਹੈ; Python service ਵਿੱਚ ਤੁਸੀਂ documented HMAC ਦੇ ਖਿਲਾਫ ਖੁਦ verify ਕਰਦੇ ਹੋ। ਆਪਣੇ store ਵਿੱਚ caller ਨੂੰ paid mark ਕਰੋ, ਅਤੇ ਤੁਹਾਡਾ gated query tool ਅਗਲੀ call ਨੂੰ ਹੋਣ ਦਿੰਦਾ ਹੈ। ਹੇਠਾਂ FastAPI example ਹੈ।
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}
Algorithm t.rawBody string ਉੱਤੇ HMAC-SHA256, constant-time compare, ਅਤੇ 300-second replay window ਹੈ। Raw body ਨੂੰ await request.body() ਰਾਹੀਂ ਪੜ੍ਹੋ, ਕਦੇ ਵੀ request.json() re-serialized ਨਾ ਕਰੋ, ਕਿਉਂਕਿ ਇਸ ਨਾਲ signature ਵੱਲੋਂ cover ਕੀਤੇ bytes ਬਦਲ ਜਾਂਦੇ ਹਨ। Shipped events ਹਨ payment.received, payment.sent, wallet.deployed, ਅਤੇ webhook.test। ਭਾਰੀ follow-up ਕੰਮ ਲਈ, job queue ਕਰੋ (Celery, arq) ਅਤੇ handler ਨੂੰ block ਕਰਨ ਦੀ ਬਜਾਏ ਤੁਰੰਤ 200 respond ਕਰੋ।
ਜਿਸ client ਨੂੰ ਤੁਸੀਂ wrap ਕਰ ਰਹੇ ਹੋ ਉਹ open ਹੈ। ਉਸਨੂੰ ਪੜ੍ਹੋ।
ਕੋਈ LlamaIndex starter package ਨਹੀਂ ਹੈ ਜਿਸਨੂੰ clone ਕੀਤਾ ਜਾ ਸਕੇ - ਉੱਪਰ ਦਿੱਤਾ 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 ਪੈਕੇਜ ਨਹੀਂ ਹੈ - ਤੁਸੀਂ ਐਸਡੀਕੇ ਨੂੰ ਲਪੇਟਦੇ ਹੋ
Blockchain0x LangChain ਅਤੇ CrewAI ਲਈ adapters ਦੇ ਨਾਲ MCP server ਵੀ ships ਕਰਦਾ ਹੈ; LlamaIndex ਲਈ ਕੋਈ dedicated package ਨਹੀਂ ਹੈ। ਉੱਪਰ ਦਿੱਤਾ recipe ਹੀ ਰਾਹ ਹੈ: ਇੱਕ plain typed function ਜੋ ਅਸਲੀ blockchain0x client ਨੂੰ call ਕਰਦੀ ਹੈ, ਅਤੇ FunctionTool.from_defaults ਨਾਲ wrap ਕੀਤੀ ਜਾਂਦੀ ਹੈ। LlamaIndex schema ਬਣਾਉਣ ਲਈ signature ਅਤੇ docstring ਪੜ੍ਹਦਾ ਹੈ, ਇਸ ਲਈ docstring ਨੂੰ ਸਹੀ ਰੱਖੋ।
QueryEngineTool ਨੂੰ ਆਪਣੇ ਆਪ ਗੇਟ ਕਰੋ - ਕੋਈ ਸਹਾਇਕ ਇਹ ਨਹੀਂ ਕਰਦਾ
paid-RAG pattern ਅਸਲੀ ਅਤੇ ਵਧੀਆ ਹੈ, ਪਰ ਕੋਈ paid_query_engine_tool helper ਨਹੀਂ ਹੈ। ਤੁਸੀਂ ਇਸਨੂੰ ਖੁਦ ਬਣਾਉਂਦੇ ਹੋ: ਆਪਣੇ query tool ਦੇ function ਵਿੱਚ check ਕਰੋ ਕਿ ਕੀ caller ਨੇ pay ਕੀਤਾ ਹੈ (ਤੁਹਾਡਾ ਆਪਣਾ store, ਜੋ ਹੇਠਾਂ ਦਿੱਤੇ webhook ਨਾਲ update ਹੁੰਦਾ ਹੈ) ਅਤੇ retrieval ਸਿਰਫ਼ ਤਦੋਂ ਚਲਾਓ ਜਦੋਂ ਉਹਨਾਂ ਨੇ pay ਕੀਤਾ ਹੋਵੇ, ਨਹੀਂ ਤਾਂ ਇੱਕ price return ਕਰੋ। ਇਹ ਕੁਝ ਹੀ lines ਹਨ, ਅਤੇ gating policy ਉੱਤੇ control ਤੁਹਾਡੇ ਕੋਲ ਰਹਿੰਦਾ ਹੈ।
ਰਕਮਾਂ 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 ਡਿਫਾਲਟ ਵਜੋਂ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰਦਾ ਅਤੇ ਤੁਹਾਡੇ ਨੈੱਟਵਰਕ ਲਈ ਚੇਨ ਐਡਾਪਟਰ ਵਾਇਰ ਹੋਣ ਤੱਕ 503 ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ। ਗਲਤੀ ਨੂੰ ਆਪਣੇ ਟੂਲ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਪਕੜੋ ਅਤੇ ਇੱਕ ਸਾਫ਼ ਸੁਨੇਹਾ ਵਾਪਸ ਕਰੋ ਜਿਸ 'ਤੇ ਮਾਡਲ ਕਾਰਵਾਈ ਕਰ ਸਕਦਾ ਹੈ, ਬਜਾਏ ਏਜੰਟ ਨੂੰ ਲੂਪ ਕਰਨ ਦੇ। ਆਟੋ-ਮਿੰਟ ਕੀਤੀ ਗਈ idempotency ਕੁੰਜੀ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਹੱਥ ਨਾਲ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਨਾਲ ਦੋਹਰਾ ਭੁਗਤਾਨ ਨਹੀਂ ਹੋਵੇਗਾ।