Agno പണമടച്ച സംയോജനം.
Agno പാക്കേജ് ഇല്ല, നിങ്ങൾക്ക് ഒന്നും ആവശ്യമില്ല. യഥാർത്ഥ blockchain0x ക്ലയന്റിനെ ഒരു ചെറിയ Toolkit-ൽ മൂടുക, നിങ്ങളുടെ ഏജന്റ് Base-ൽ USDC നീക്കാൻ കഴിയും - കുറഞ്ഞ ആബ്സ്ട്രാക്ഷൻ, Agno മാർഗം.
Agno-യ്ക്ക് പ്രത്യേക package ഒന്നുമില്ല, അതിന് നിങ്ങൾക്ക് ആവശ്യവും ഇല്ല. Agno ഒരു method-നെ tool ആക്കുന്നതിനാൽ, real Python client-നെ ഒരു ചെറിയ toolkit-ൽ wrap ചെയ്ത് നിങ്ങളുടെ -ൽ ചേർക്കുക. agent-ന് USDC അയക്കാനും, invoices settle ചെയ്യാനും, wallets വായിക്കാനും കഴിയും, എല്ലാ Agno model-കളിലും (OpenAI, Anthropic, DeepSeek, Llama, Mistral). Payments Base-ൽ settle ചെയ്യും.
ലഘുവായ Python ഫ്രെയിംവർക്കാണ്. യാഥാർത്ഥ്യ നികുതി ഇല്ല.
Agno (മുൻപ് Phidata) നിങ്ങൾക്ക് കുറഞ്ഞ ചടങ്ങുകൾ ആവശ്യമുണ്ടെങ്കിൽ നിങ്ങൾ കൈവശം വയ്ക്കുന്ന ഏജന്റ് ഫ്രെയിംവർക്കാണ്. ഗ്രാഫ് നിർമ്മാതാവ്, ക്രൂ, വർക്ക്ഫ്ലോ ഇല്ല - വെറും ഏജന്റ്, ഉപകരണങ്ങൾ, run() രീതിയാണ്. ഉപകരണങ്ങൾ Python callable ആണ്. ഫ്രെയിംവർക്ക് ഉപകരണ പിന്തുണയോടെ LLMകൾ വിളിക്കാൻ, മെമ്മറി കൈകാര്യം ചെയ്യാൻ, സ്ട്രീമിംഗ് ഔട്ട്പുട്ട് നിർമ്മിക്കാൻ ആവശ്യമായ scaffolding കൂട്ടിച്ചേർക്കുന്നു, പിന്നെ നിങ്ങളുടെ വഴിയിൽ നിന്ന് മാറുന്നു.
ഈ റെസിപ്പി സമാനമായ തത്വശാസ്ത്രം പിന്തുടരുന്നു. നിങ്ങൾ ഒരു ചെറിയ Toolkit ഉപവിഭാഗം എഴുതുന്നു, അത് യഥാർത്ഥ ക്ലയന്റിനെ വിളിക്കുന്ന ഒരു രീതിയെ രജിസ്റ്റർ ചെയ്യുന്നു - ഇത് മറ്റുള്ള എല്ലാ Agno ഉപകരണങ്ങളുടെയും പോലെ കാണപ്പെടുകയും പെരുമാറുകയും ചെയ്യുന്നു. ഇൻസ്റ്റൻഷനിൽ നിന്ന് പുറത്തുള്ള പ്രത്യേക ക്രമീകരണം ഇല്ല, ബന്ധിപ്പിക്കാൻ ഗ്രാഫ് ഇല്ല, ട്രാക്ക് ചെയ്യാൻ അഡാപ്റ്റർ പതിപ്പ് ഇല്ല. ലളിതമായതിന്റെ ലക്ഷ്യം: നിങ്ങൾക്ക് ഗ്രാഫുകൾ വേണമെങ്കിൽ നിങ്ങൾ LangGraph-ൽ ആയിരിക്കുമായിരുന്നു.
Agno ഇൻസ്റ്റാൾ ചെയ്യുക, കൂടാതെ കോർ SDK. രണ്ട് കീകൾ.
ചേർക്കാൻ blockchain0x Agno പാക്കേജ് ഇല്ല. നിങ്ങൾ Agno (Python 3.10+, Phidata പുനർനാമീകരണത്തിന് ശേഷം 1.0+ വരി) ഇൻസ്റ്റാൾ ചെയ്യുന്നു, യഥാർത്ഥ blockchain0x കോർ SDK, പിന്നെ താഴെ ടൂൾകിറ്റ് എഴുതുന്നു. നിങ്ങൾ ഇപ്പോഴും 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-ിന്റെയും സമാനമായത്). BLOCKCHAIN0X_API_KEY നിങ്ങളുടെ dashboard-ലുള്ള sk_test_ testnet അല്ലെങ്കിൽ sk_live_ mainnet കീ ആണ്; client അതിനെ environment-ൽ നിന്ന് വായിക്കുന്നു. നിങ്ങളുടെ agent-ിന് money സ്വീകരിക്കാനുമുണ്ടെങ്കിൽ, webhook handler-ിന് കൂടാതെ BLOCKCHAIN0X_WEBHOOK_SECRET ആവശ്യമാണ്.
ഒരു Toolkit, ഏജന്റിന് കൈമാറുന്നു.
താഴെ മുഴുവൻ സംയോജനം ആണ്. WalletTools send_usdc രജിസ്റ്റർ ചെയ്യുന്ന ഒരു Toolkit ഉപവിഭാഗമാണ്, ഇത് യഥാർത്ഥ 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 സ്വീകരിക്കുന്നുവെങ്കിൽ, polling വഴി അല്ലാതെ വെബ്ഹുക്ക് ഉപയോഗിച്ച് ഇത് സ്ഥിരീകരിക്കുക. verify സഹായി 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}
അൽഗോറിതം t.rawBody എന്ന വരിയിൽ HMAC-SHA256 ആണ്, സ്ഥിരമായ സമയത്ത് താരതമ്യം ചെയ്യുന്നു, 300-സെക്കൻഡ് പുനരാവൃത്തി വിൻഡോ. ഒപ്പുവെച്ചതിന്റെ അക്ഷരരൂപം നിലനിർത്താൻ await request.body() വഴി കച്ചവട ബോഡി വായിക്കുക, request.json() വീണ്ടും സീരിയലൈസ് ചെയ്യരുത്, കാരണം അത് ഒപ്പുവെച്ചതിന്റെ പരിധിയിൽ വരുന്ന ബൈറ്റുകൾ മാറ്റുന്നു. അയച്ച ഇവന്റുകൾ payment.received, payment.sent, wallet.deployed, webhook.test എന്നിവയാണ്. ഭാരമുള്ള പിന്തുടർച്ചാ പ്രവർത്തനങ്ങൾക്ക്, ഒരു ജോലി (Celery, arq) enqueue ചെയ്യുക, ഹാൻഡ്ലർ തടയുന്നതിന് പകരം ഉടൻ 200 പ്രതികരിക്കുക.
നിങ്ങൾ വ്രാപ്പ് ചെയ്യുന്ന ക്ലയന്റ് തുറന്നതാണ്. അത് വായിക്കുക.
clone ചെയ്യാൻ വേറെ Agno starter package ഇല്ല - മുകളിലെ 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 ൽ രേഖപ്പെടുത്തിയിരിക്കുന്നു. Base Sepolia-യിൽ sk_test_ key ഉപയോഗിച്ച് ആരംഭിക്കുക, തുടർന്ന് toolkit നിങ്ങൾ പ്രതീക്ഷിക്കുന്നതു പോലെ പ്രവർത്തിക്കുമ്പോൾ sk_live_ ആയി മാറുക.
കണ്ടു പിടിക്കേണ്ട അഞ്ചു Agno-നിഷ്ഠമായ കാര്യങ്ങൾ.
Agno സംയോജിപ്പിക്കാൻ ഏറ്റവും ശുദ്ധമായ ഏജന്റ് ഫ്രെയിംവർക്കുകളിൽ ഒന്നാണ്, എന്നാൽ അതിന് സ്വന്തം പ്രശ്നങ്ങൾ ഉണ്ട് - പ്രത്യേകിച്ച് Phidata പുനർനാമകരണം ചെയ്യുന്നതും മാർക്ക്ഡൗൺ റെൻഡറിംഗ് ചെയ്യുന്നതും.
Agno പാക്കേജ് ഇല്ല - നിങ്ങൾ SDK-യെ ഒരു Toolkit-ൽ മൂടുന്നു
Blockchain0x LangChain, CrewAI, MCP സെർവറിന് അഡാപ്റ്ററുകൾ അയക്കുന്നു; പ്രത്യേക Agno പാക്കേജ് ഇല്ല. മുകളിൽ നൽകിയ റെസിപ്പി വഴി: യഥാർത്ഥ blockchain0x ക്ലയന്റ് വിളിക്കുന്ന ഒരു രീതിയെ രജിസ്റ്റർ ചെയ്യുന്ന ഒരു Toolkit ഉപവിഭാഗം. Agno സ്കീമ നിർമ്മിക്കാൻ രീതി സിഗ്നേച്ചർ, ഡോക്സ്ട്രിംഗ് എന്നിവ വായിക്കുന്നു, അതിനാൽ ഡോക്സ്ട്രിംഗ് കൃത്യമായിരിക്കണം.
Phidata to 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() വിളിക്കുക, ഫലത്തെ കാത്തിരിക്കുക, നിങ്ങൾക്ക് ഒരു സ്ട്രിംഗ് പ്രതീക്ഷിച്ച സ്ഥലത്ത് ഒരു coroutine ലഭിക്കും. Toolkit-ൽ ഉള്ള blockchain0x വിളി സമകാലികമാണ്; നിങ്ങൾ async പാതയിൽ ആണെങ്കിൽ, യാഥാർത്ഥ്യ വോള്യം കൈമാറുന്നുവെങ്കിൽ, asyncio.to_thread-ൽ ചുറ്റിക്കൊണ്ട് ഇവന്റ് ലൂപ്പ് പ്രതികരണശേഷിയുള്ളതാക്കുക.
വെബ്ഹുക്കുകൾ കച്ചവട ബോഡി എതിരെ സ്ഥിരീകരിക്കുക
നിങ്ങളുടെ ഏജന്റ് USDC സ്വീകരിക്കുന്നുവെങ്കിൽ, polling വഴി അല്ലാതെ വെബ്ഹുക്ക് ഉപയോഗിച്ച് ഇത് സ്ഥിരീകരിക്കുക. RAW അഭ്യർത്ഥന ബൈറ്റുകൾ (await request.body()) മുകളിൽ ഒപ്പിടൽ സ്ഥിരീകരിക്കുക, ഒരിക്കലും request.json() വീണ്ടും സീരിയലൈസ് ചെയ്യരുത്, കാരണം HMAC കൃത്യമായ ബൈറ്റുകൾ ഉൾക്കൊള്ളുന്നു. ഇത് 300-സെക്കൻഡ് റിപ്ലേ വിൻഡോയോടുകൂടിയ HMAC-SHA256 ആണ്. താഴെയുള്ള ഹാൻഡ്ലർ മുഴുവൻ കാര്യമാണ്.