Agno ਭੁਗਤਾਨ ਇੰਟਿਗਰੇਸ਼ਨ।
ਕੋਈ Agno ਪੈਕੇਜ ਨਹੀਂ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇੱਕ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਅਸਲੀ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਇੱਕ ਛੋਟੇ ਟੂਲਕਿਟ ਵਿੱਚ ਲਪੇਟੋ ਅਤੇ ਤੁਹਾਡਾ ਏਜੰਟ USDC ਨੂੰ ਬੇਸ 'ਤੇ ਚਲਾ ਸਕਦਾ ਹੈ - ਘੱਟੋ-ਘੱਟ ਅਬਸਟ੍ਰੈਕਸ਼ਨ, Agno ਦਾ ਤਰੀਕਾ।
Agno-specific ਕੋਈ package ਨਹੀਂ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇਸਦੀ ਲੋੜ ਵੀ ਨਹੀਂ। Agno ਇੱਕ method ਨੂੰ tool ਵਿੱਚ ਬਦਲਦਾ ਹੈ, ਇਸ ਲਈ ਤੁਸੀਂ ਅਸਲੀ Python client ਨੂੰ ਇੱਕ ਛੋਟੇ toolkit ਵਿੱਚ wrap ਕਰਦੇ ਹੋ ਅਤੇ ਆਪਣੇ ਵਿੱਚ add ਕਰਦੇ ਹੋ। Agent USDC ਭੇਜ ਸਕਦਾ ਹੈ, invoices settle ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ wallets ਪੜ੍ਹ ਸਕਦਾ ਹੈ, Agno ਦੇ ਹਰ model (OpenAI, Anthropic, DeepSeek, Llama, Mistral) across. Payments Base 'ਤੇ settle ਹੁੰਦੀਆਂ ਹਨ।
ਹਲਕਾ ਫੁਲਕਾ Python ਫਰੇਮਵਰਕ। ਕੋਈ ਅਬਸਟਰੈਕਸ਼ਨ ਟੈਕਸ ਨਹੀਂ।
Agno (ਪਹਿਲਾਂ Phidata) ਉਹ ਏਜੰਟ ਫਰੇਮਵਰਕ ਹੈ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਘੱਟ ਤੋਂ ਘੱਟ ਸਮਾਰੋਹ ਚਾਹੁੰਦੇ ਹੋ। ਕੋਈ ਗ੍ਰਾਫ ਬਿਲਡਰ ਨਹੀਂ, ਕੋਈ ਕ੍ਰੂ ਨਹੀਂ, ਕੋਈ ਵਰਕਫਲੋ ਨਹੀਂ - ਸਿਰਫ ਏਜੰਟ, ਟੂਲ ਅਤੇ ਇੱਕ run() ਵਿਧੀ। ਟੂਲ ਪਾਇਥਨ ਕਾਲੇਬਲ ਹਨ। ਫਰੇਮਵਰਕ LLMs ਨੂੰ ਟੂਲ ਸਹਾਇਤਾ ਨਾਲ ਕਾਲ ਕਰਨ, ਯਾਦ ਪ੍ਰਬੰਧਿਤ ਕਰਨ, ਅਤੇ ਸਟ੍ਰੀਮਿੰਗ ਆਉਟਪੁੱਟ ਉਤਪਾਦਿਤ ਕਰਨ ਲਈ ਕਾਫੀ ਸਕੈਫੋਲਡਿੰਗ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ, ਫਿਰ ਤੁਹਾਡੇ ਰਸਤੇ ਤੋਂ ਦੂਰ ਹੋ ਜਾਂਦਾ ਹੈ।
Recipe ਵੀ ਉਹੀ philosophy follow ਕਰਦੀ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਛੋਟੀ Toolkit subclass ਲਿਖਦੇ ਹੋ ਜੋ ਇੱਕ ਐਸੀ method register ਕਰਦੀ ਹੈ ਜੋ real client ਨੂੰ call ਕਰਦੀ ਹੈ - ਇਹ ਹਰ ਹੋਰ Agno tool ਵਾਂਗ ਦਿਖਦੀ ਅਤੇ ਵਰਤਦੀ ਹੈ। Instantiation ਤੋਂ ਇਲਾਵਾ ਕੋਈ special setup ਨਹੀਂ, wire up ਕਰਨ ਲਈ ਕੋਈ graph ਨਹੀਂ, track ਕਰਨ ਲਈ ਕੋਈ adapter version ਨਹੀਂ। ਸਾਦਗੀ ਹੀ point ਹੈ: ਜੇ ਤੁਹਾਨੂੰ graphs ਚਾਹੀਦੇ ਹੁੰਦੇ, ਤਾਂ ਤੁਸੀਂ LangGraph 'ਤੇ ਹੁੰਦੇ।
Agno ਅਤੇ ਕੋਰ SDK ਨੂੰ ਇੰਸਟਾਲ ਕਰੋ। ਦੋ ਕੁੰਜੀਆਂ।
ਕੋਈ blockchain0x Agno ਪੈਕੇਜ ਨਹੀਂ ਹੈ ਜੋ ਜੋੜਿਆ ਜਾ ਸਕੇ। ਤੁਸੀਂ Agno (Python 3.10+, Phidata ਨਾਮ ਬਦਲਣ ਤੋਂ ਬਾਅਦ 1.0+ ਲਾਈਨ) ਅਤੇ ਅਸਲੀ blockchain0x ਕੋਰ ਐਸਡੀਕੇ ਨੂੰ ਇੰਸਟਾਲ ਕਰਦੇ ਹੋ, ਫਿਰ ਹੇਠਾਂ ਦਿੱਤਾ ਟੂਲਕਿਟ ਲਿਖਦੇ ਹੋ। ਜੇ ਤੁਸੀਂ ਹਾਲੇ ਵੀ phi.* ਆਯਾਤਾਂ 'ਤੇ ਹੋ, ਤਾਂ ਪਹਿਲਾਂ pip install -U agno ਚਲਾਓ।
pip install agno blockchain0xexport OPENAI_API_KEY=sk-... export BLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
OPENAI_API_KEY (ਜਾਂ ਜਿਸ Agno-supported model ਨੂੰ ਤੁਸੀਂ ਵਰਤਦੇ ਹੋ, ਉਸਦੇ equivalent). BLOCKCHAIN0X_API_KEY ਤੁਹਾਡੇ dashboard ਤੋਂ ਇੱਕ sk_test_ testnet ਜਾਂ sk_live_ mainnet key ਹੈ; client ਇਸਨੂੰ environment ਤੋਂ ਪੜ੍ਹਦਾ ਹੈ। ਜੇ ਤੁਹਾਡਾ agent ਪੈਸੇ ਵੀ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਤਾਂ webhook handler ਨੂੰ ਵਾਧੂ ਤੌਰ 'ਤੇ BLOCKCHAIN0X_WEBHOOK_SECRET ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
ਇੱਕ ਟੂਲਕਿਟ ਜੋ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ, ਇੱਕ ਏਜੰਟ ਨੂੰ ਦਿੱਤਾ ਗਿਆ.
ਹੇਠਾਂ ਪੂਰੀ ਇੰਟਿਗ੍ਰੇਸ਼ਨ ਹੈ। WalletTools ਇੱਕ Toolkit ਉਪਵਰਗ ਹੈ ਜੋ send_usdc ਨੂੰ ਰਜਿਸਟਰ ਕਰਦਾ ਹੈ, ਜੋ ਅਸਲ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। ਇਸਨੂੰ ਏਜੰਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ ਅਤੇ run() ਕਾਲ ਟੂਲ ਦੀ ਪੁਕਾਰ ਨੂੰ ਆਰਕੀਸਟ੍ਰੇਟ ਕਰਦੀ ਹੈ। Agno ਵਿਧੀ ਦੇ ਦਸਤਖਤ ਅਤੇ ਡੌਕਸਟ੍ਰਿੰਗ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਤਾਂ ਜੋ ਸਕੀਮਾ ਬਣਾਇਆ ਜਾ ਸਕੇ।
from agno.agent import Agent from agno.models.openai import OpenAIChat from agno.tools import Toolkit from blockchain0x import Client blockchain0x = Client() # reads BLOCKCHAIN0X_API_KEY from the environment # Wrap the real client in an Agno Toolkit. No dedicated package needed. class WalletTools(Toolkit): def __init__(self): super().__init__(name="wallet_tools") self.register(self.send_usdc) def send_usdc(self, 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}) ) agent = Agent( model=OpenAIChat(id="gpt-4o"), tools=[WalletTools()], instructions=["You pay vendor invoices in USDC within owner-set limits."], ) result = agent.run("Pay 0.01 USDC from agent agt_123 to 0xVendor for the dataset.") print(result.content)
When agent.run() executes, the model decides to pay, 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_. Register more methods on the toolkit - read a wallet, settle an invoice - the same way.
ਇੱਕ ਸਾਈਨ ਕੀਤੀ ਵੈਬਹੂਕ ਨਾਲ ਆਉਣ ਵਾਲੇ ਭੁਗਤਾਨਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ।
ਜੇ ਤੁਹਾਡਾ ਏਜੰਟ ਵੀ USDC ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ webhook ਨਾਲ ਪੁਸ਼ਟੀ ਕਰੋ ਨਾ ਕਿ ਪੁਸ਼ਟੀ ਕਰਨ ਨਾਲ। ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਵਾਲਾ ਸਹਾਇਕ Node SDK ਵਿੱਚ ਸ਼ਿਪ ਕੀਤਾ ਜਾਂਦਾ ਹੈ; ਇੱਕ Python ਸੇਵਾ ਵਿੱਚ ਤੁਸੀਂ ਦਸਤਾਵੇਜ਼ HMAC ਦੇ ਖਿਲਾਫ ਹੱਥ ਨਾਲ ਪ੍ਰਮਾਣਿਤ ਕਰਦੇ ਹੋ, ਜੋ ਕਿ ਸਹਾਇਕ ਕਰਦਾ ਹੈ। ਹੇਠਾਂ FastAPI ਉਦਾਹਰਨ; ਉਹੀ ਕੋਡ ਕਿਸੇ ਵੀ ਅਸਿੰਕ Python ਫਰੇਮਵਰਕ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ।
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 - run the next step 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 ਹੈ। ਉਸਨੂੰ ਪੜ੍ਹੋ।
ਕੋਈ Agno starter package ਨਹੀਂ ਹੈ ਜਿਸਨੂੰ clone ਕੀਤਾ ਜਾ ਸਕੇ - ਉੱਪਰ ਦਿੱਤਾ recipe ਹੀ integration ਹੈ। blockchain0x SDKs GitHub 'ਤੇ open source ਹਨ; ਇਹ recipe Python SDK (blockchain0x-python) ਨੂੰ wrap ਕਰਦੀ ਹੈ, ਅਤੇ ਪੂਰੀ method surface docs ਵਿੱਚ ਹੈ। toolkit methods ਲਈ reference ਵਜੋਂ ਇਸਨੂੰ ਪੜ੍ਹੋ।
github.com/tosh-labs/blockchain0x-pythonਪੂਰਾ SDK method surface ਅਤੇ scopes the docs 'ਤੇ documented ਹਨ। Base Sepolia ਦੇ ਖ਼ਿਲਾਫ਼ sk_test_ key ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ, ਫਿਰ ਜਦੋਂ toolkit ਤੁਹਾਡੀ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰੇ, sk_live_ 'ਤੇ switch ਕਰੋ।
ਪੰਜ Agno-ਵਿਸ਼ੇਸ਼ ਚੀਜ਼ਾਂ ਜੋ ਦੇਖਣ ਲਈ।
Agno ਇੱਕ ਸਾਫ਼ ਏਜੰਟ ਫਰੇਮਵਰਕ ਹੈ ਜਿਸ ਨਾਲ ਇੰਟਿਗਰੇਟ ਕਰਨਾ ਹੈ, ਪਰ ਇਸ ਵਿੱਚ ਆਪਣੇ ਹੀ ਗੋਟਚਾਸ ਹਨ - ਖਾਸ ਕਰਕੇ Phidata ਦਾ ਨਾਮ ਬਦਲਣ ਅਤੇ ਮਾਰਕਡਾਊਨ ਰੇਂਡਰਿੰਗ ਦੇ ਆਸਪਾਸ।
ਕੋਈ Agno ਪੈਕੇਜ ਨਹੀਂ ਹੈ - ਤੁਸੀਂ SDK ਨੂੰ ਇੱਕ ਟੂਲਕਿਟ ਵਿੱਚ ਲਪੇਟਦੇ ਹੋ
Blockchain0x LangChain ਅਤੇ CrewAI ਲਈ ਐਡਾਪਟਰਾਂ ਨੂੰ ਭੇਜਦਾ ਹੈ ਅਤੇ MCP ਸਰਵਰ; ਕੋਈ ਸਮਰਪਿਤ Agno ਪੈਕੇਜ ਨਹੀਂ ਹੈ। ਉਪਰੋਕਤ ਨੁਸਖਾ ਉਹ ਰਸਤਾ ਹੈ: ਇੱਕ Toolkit ਉਪਵਰਗ ਜੋ ਇੱਕ ਵਿਧੀ ਨੂੰ ਰਜਿਸਟਰ ਕਰਦਾ ਹੈ ਜੋ ਅਸਲ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। Agno ਵਿਧੀ ਦੇ ਦਸਤਖਤ ਅਤੇ ਡੌਕਸਟ੍ਰਿੰਗ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਤਾਂ ਜੋ ਟੂਲ ਸਕੀਮਾ ਬਣਾਇਆ ਜਾ ਸਕੇ, ਇਸ ਲਈ ਡੌਕਸਟ੍ਰਿੰਗ ਨੂੰ ਸਹੀ ਰੱਖੋ।
Phidata ਤੋਂ Agno ਮਾਈਗ੍ਰੇਸ਼ਨ ਗੁੰਝਲ
Agno ਦਾ ਨਾਮ 2024 ਵਿੱਚ Phidata ਤੋਂ ਬਦਲਿਆ ਗਿਆ ਸੀ। phi.agent ਜਾਂ phi.tools ਤੋਂ ਆਮਦ ਕਰਨ ਵਾਲੀਆਂ ਪੁਰਾਣੀਆਂ ਕੋਡਬੇਸ ਹੁਣ ਵੀ ਇੱਕ ਅਨੁਕੂਲਤਾ ਸ਼ਿਮ ਦੁਆਰਾ ਕੰਮ ਕਰਦੀਆਂ ਹਨ, ਪਰ agno.* ਆਮਦ ਹੁਣ ਦੇ ਹਨ। ਨੁਸਖਾ agno.* ਦਾ ਉਪਯੋਗ ਕਰਦਾ ਹੈ; ਜੇ ਤੁਹਾਡਾ ਕੋਡ ਹਾਲੇ ਵੀ phi.* ਆਮਦ 'ਤੇ ਹੈ, ਤਾਂ pip install -U agno ਚਲਾਓ ਅਤੇ Toolkit ਸ਼ਾਮਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਆਮਦ ਪਾਥ ਬਦਲੋ।
ਰਕਮਾਂ USDC ਬੇਸ ਯੂਨਿਟ ਹਨ, ਸਤਰਾਂ ਵਜੋਂ
payments.create takes amountWei: a string of USDC base units (6 decimals), so 0.01 USDC is "10000" and 5 USDC is "5000000". Type the method argument as str. It also does not retry by default and can answer 503 until the chain adapter is wired for your network - return a clear message rather than letting the agent loop.
ਸਿੰਕ vs ਐਸਿੰਕ ਚਲਾਉਣਾ
Agno agent.run() (sync) ਅਤੇ agent.arun() (async) ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਹਰ ਏਜੰਟ ਲਈ ਇੱਕ ਮੋਡ ਚੁਣੋ - agent.run() ਨੂੰ ਕਾਲ ਕਰੋ ਅਤੇ ਨਤੀਜੇ ਦੀ ਉਮੀਦ ਕਰੋ ਅਤੇ ਤੁਹਾਨੂੰ ਇੱਕ ਕੋਰੂਟੀਨ ਮਿਲੇਗਾ ਜਿੱਥੇ ਤੁਸੀਂ ਇੱਕ ਸਤਰ ਦੀ ਉਮੀਦ ਕਰਦੇ ਹੋ। Toolkit ਦੇ ਅੰਦਰ blockchain0x ਕਾਲ ਸਮਕਾਲੀ ਹੈ; ਜੇ ਤੁਸੀਂ async ਮਾਰਗ 'ਤੇ ਹੋ ਅਤੇ ਅਸਲੀ ਵੋਲਿਊਮ ਚਲਾ ਰਹੇ ਹੋ, ਤਾਂ ਇਸਨੂੰ asyncio.to_thread ਨਾਲ ਲਪੇਟੋ ਤਾਂ ਜੋ ਇਵੈਂਟ ਲੂਪ ਜਵਾਬਦਾਰ ਰਹੇ।
ਵੈਬਹੂਕ ਨੂੰ ਕੱਚੇ ਸਰੀਰ ਦੇ ਖਿਲਾਫ ਪੁਸ਼ਟੀ ਕਰੋ
ਜੇ ਤੁਹਾਡਾ ਏਜੰਟ ਵੀ USDC ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ webhook ਨਾਲ ਪੁਸ਼ਟੀ ਕਰੋ, ਪੁਸ਼ਟੀ ਕਰਨ ਨਾਲ ਨਹੀਂ। RAW ਬੇਨਤੀ ਬਾਈਟਸ (await request.body()) 'ਤੇ ਦਸਤਖਤ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ, ਕਦੇ ਵੀ request.json() ਦੁਬਾਰਾ-ਸਿਰਜਿਆ ਨਹੀਂ, ਕਿਉਂਕਿ HMAC ਸਹੀ ਬਾਈਟਾਂ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ। ਇਹ HMAC-SHA256 ਹੈ ਜਿਸ ਵਿੱਚ 300-ਸੈਕੰਡ ਦਾ ਦੁਬਾਰਾ ਖੇਡਣ ਦਾ ਵਿੰਡੋ ਹੈ। ਹੇਠਾਂ ਦਿੱਤਾ ਹੈਂਡਲਰ ਪੂਰੀ ਗੱਲ ਹੈ।