LlamaIndex betalingsintegratie.
Er is geen LlamaIndex-pakket, en je hebt er geen nodig. Wikkel de echte blockchain0x-client in een FunctionTool en jouw agent kan USDC verplaatsen en een betaalde RAG-query op Base beheren.
Er is geen LlamaIndex-specifiek pakket, en je hebt er ook geen nodig. LlamaIndex maakt van een gewone functie een tool met , dus wikkel je de echte Python client in een functie en voeg je die toe aan een of . De agent kan USDC versturen, facturen afwikkelen en wallets uitlezen. Om per RAG-query te rekenen, beveilig je je eigen QueryEngineTool op dezelfde manier. Betalingen worden afgerekend op Base.
RAG-queries zijn duur. Betalen per query maakt de economie werkbaar.
De kracht van LlamaIndex is retrieval-augmented generation: u heeft een vectorindex over eigendomsdocumenten (de documenten van uw bedrijf, een onderzoeksdataset, een juridische corpus), en de agent beantwoordt door de relevante stukken op te halen en samen te vatten. Elke query kost echt geld in embeddings, LLM-tokens en vaak derde partij API-aanroepen. Vrije onbeperkte toegang verbruikt budget; per-query facturering past bij de kostenstructuur.
Er is geen verzonden helper voor dit, en je hebt er geen nodig. Je beheert het zelf: binnen de functie van jouw QueryEngineTool, controleer of de beller heeft betaald (jouw eigen vlag, omgedraaid door de betaling-webhook) en voer ofwel de retrieval uit of retourneer een prijs. De wallet-functie en het beheer zijn beide een paar regels boven de echte blockchain0x-client, die het beleid - per query, per sessie, gratis laag dan betaald - volledig in jouw handen houdt.
Installeer LlamaIndex en de kern SDK. Eén omgevingsvariabele.
Er is geen blockchain0x LlamaIndex-pakket om toe te voegen. Je installeert LlamaIndex (Python 3.10+, de moderne FunctionAgent / ReActAgent / Workflows API's) en de echte blockchain0x kern SDK, en schrijft dan de functie hieronder. Werkt naast elke vectoropslag - 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 is een sk_test_ testnet- of sk_live_ mainnet-sleutel uit je dashboard; de client leest deze uit de omgeving. Als je betaalde queries afschermt, heeft de webhook-handler daarnaast BLOCKCHAIN0X_WEBHOOK_SECRET nodig, die het dashboard één keer teruggeeft wanneer je een webhook aanmaakt of roteert.
Een functie die betaalt, verpakt als een FunctionTool.
Hieronder is de hele integratie. send_usdc roept de echte blockchain0x-client aan; FunctionTool.from_defaults wikkelt het in, en FunctionAgent pakt het op als een aanroepbaar hulpmiddel. LlamaIndex leest de type hints en docstring om het schema op te bouwen. Voeg uw eigen QueryEngineTool toe aan de lijst en dezelfde agent kan ook RAG-vragen beantwoorden.
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.
Draai de betaald-vlag om wanneer de webhook aankomt.
Wanneer een betaling wordt afgehandeld, POST Blockchain0x een ondertekende payment.received-gebeurtenis naar je webhook-URL. De verify-helper wordt geleverd in de Node SDK; in een Python-service verifieer je met de hand tegen de gedocumenteerde HMAC. Markeer de beller als betaald in je eigen opslag, en je gated query-tool laat de volgende oproep door. FastAPI-voorbeeld hieronder.
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}
Het algoritme is HMAC-SHA256 over de string t.rawBody, een constante tijdsvergelijking, en een replayvenster van 300 seconden. Lees het ruwe lichaam via await request.body(), nooit request.json() opnieuw-serialized, omdat dat de bytes verandert die de handtekening dekt. De verzonden evenementen zijn payment.received, payment.sent, wallet.deployed, en webhook.test. Voor zware vervolgwerkzaamheden, voeg een taak toe (Celery, arq) en reageer onmiddellijk met 200 in plaats van de handler te blokkeren.
De client die je aan het wikkelen bent is open. Lees het.
Er is geen LlamaIndex starter package om te klonen - de bovenstaande recipe is de integratie. De blockchain0x SDKs zijn open source op GitHub; deze recipe omhult de Python SDK (blockchain0x-python), met de volledige method surface in de docs. Lees die als referentie voor de function bodies.
github.com/tosh-labs/blockchain0x-pythonDe volledige SDK method surface en scopes zijn gedocumenteerd in de docs. Begin met een sk_test_ key op Base Sepolia en schakel daarna over naar sk_live_ wanneer de functie doet wat je verwacht.
Vijf LlamaIndex-specifieke valkuilen om te vermijden.
Deze komen uit onze ondersteuningsinbox. Elk bespaart minstens een uur debuggen zodra je ervan op de hoogte bent.
Er is geen LlamaIndex-pakket - je wikkelt de SDK
Blockchain0x levert adapters voor LangChain en CrewAI plus de MCP-server; er is geen speciaal LlamaIndex-pakket. Het bovenstaande recept is het pad: een eenvoudige getypte functie die de echte blockchain0x-client aanroept, gewikkeld met FunctionTool.from_defaults. LlamaIndex leest de handtekening en docstring om het schema op te bouwen, dus houd de docstring nauwkeurig.
Beperk een QueryEngineTool zelf - geen helper doet het
Het betaalde-RAG-patroon is echt en goed, maar er is geen paid_query_engine_tool helper. Je bouwt het: in de functie van jouw querytool, controleer of de beller heeft betaald (jouw eigen opslag, bijgewerkt door de onderstaande webhook) en voer alleen de retrieval uit als ze dat hebben gedaan, anders retourneer een prijs. Het zijn een paar regels, en je behoudt de controle over het gatingbeleid.
Bedragen zijn USDC basis eenheden, als 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 is async; de SDK-aanroep is sync
LlamaIndex-agenten zijn async-first - await agent.run(...). De blockchain0x-clientaanroep binnen uw tool is synchroon, wat prima is voor een enkele snelle betaling, maar de lus blokkeert onder belasting. Als u veel gelijktijdige verzoeken bedient, wikkel dan de SDK-aanroep in asyncio.to_thread zodat de eventloop responsief blijft.
send_payment kan vroeg 503 beantwoorden
payments.create probeert standaard niet opnieuw en kan 503 retourneren totdat de chain adapter is aangesloten op jouw netwerk. Vang de fout op binnen je toolfunctie en retourneer een duidelijk bericht waar het model op kan reageren, in plaats van de agent te laten draaien. De automatisch geminte idempotency key betekent dat een handmatige herhaling niet dubbel betaalt.