Add supported payment workflows to Agno.
Agno ప్యాకేజీ లేదు, మరియు మీకు ఒకటి అవసరం లేదు. నిజమైన agentcredia క్లయింట్‌ను చిన్న Toolkitలో చుట్టండి మరియు మీ ఏజెంట్ Baseలో 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) లోనూ. Payments Base పై settle అవుతాయి.
తేలికపాటి Python ఫ్రేమ్‌వర్క్. ఎలాంటి అభ్యాసపు పన్ను లేదు.
Agno (మునుపు ఫిడేటా) మీకు కనీసం ఆచారాన్ని కోరినప్పుడు మీరు చేరుకునే ఏజెంట్ ఫ్రేమ్‌వర్క్. గ్రాఫ్ బిల్డర్ లేదు, క్రూ లేదు, వర్క్‌ఫ్లో లేదు - కేవలం ఏజెంట్, టూల్స్ మరియు ఒక run() పద్ధతి. టూల్స్ పైనాన్ కాలబుల్స్. ఫ్రేమ్‌వర్క్ టూల్ మద్దతుతో LLMలను పిలవడానికి, మెమరీని నిర్వహించడానికి మరియు స్ట్రీమింగ్ అవుట్‌పుట్‌ను ఉత్పత్తి చేయడానికి సరిపడా స్కాఫోల్డింగ్‌ను జోడిస్తుంది, తరువాత మీ మార్గం నుండి బయటకు వస్తుంది.
రెసిపీ అదే తత్వశాస్త్రాన్ని అనుసరిస్తుంది. మీరు వాస్తవ క్లయింట్‌ను కాల్ చేసే ఒక పద్ధతిని నమోదు చేసే చిన్న Toolkit ఉపవర్గాన్ని రాస్తారు - ఇది ప్రతి ఇతర Agno సాధనంలాగా కనిపిస్తుంది మరియు ప్రవర్తిస్తుంది. ఇన్స్టాంటియేషన్‌కు మించి ప్రత్యేక సెటప్ లేదు, వైర్ చేయడానికి గ్రాఫ్ లేదు, ట్రాక్ చేయడానికి అడాప్టర్ వెర్షన్ లేదు. సరళతే ముఖ్యమైనది: మీరు గ్రాఫ్‌లను కోరుకుంటే మీరు LangGraphలో ఉండేవారు.
Agno మరియు కోర్ SDKని ఇన్‌స్టాల్ చేయండి. రెండు కీలు.
చేర్చడానికి agentcredia Agno ప్యాకేజీ లేదు. మీరు Agnoని (Python 3.10+, Phidata పునర్నామకానికి తరువాత 1.0+ లైన్) మరియు నిజమైన agentcredia కోర్ SDKని ఇన్‌స్టాల్ చేస్తారు, తరువాత క్రింద టూల్‌కిట్‌ను రాస్తారు. మీరు ఇంకా phi.* దిగుమతులపై ఉంటే, మొదట pip install -U agnoను నడపండి.
pip install agno agentcrediaexport OPENAI_API_KEY=sk-... export AGENTCREDIA_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
OPENAI_API_KEY (లేదా మీరు use చేసే Agno-supported model కి సమానమైనది). AGENTCREDIA_API_KEY అనేది మీ dashboard నుంచి వచ్చిన sk_test_ testnet లేదా sk_live_ mainnet key; client దాన్ని environment నుండి reads చేస్తుంది. మీ agent కు money కూడా వస్తే, webhook handler కు అదనంగా AGENTCREDIA_WEBHOOK_SECRET అవసరం.
చెల్లించే Toolkit, ఏజెంట్‌కు అందించబడింది.
ఇది మొత్తం integration. WalletTools అనేది send_usdc ను register చేసే Toolkit subclass, అది real agentcredia client ను call చేస్తుంది. దీన్ని Agent కు add చేయండి, run() call tool invocation ను orchestrate చేస్తుంది. Agno schema build చేయడానికి method signature మరియు docstring ను reads చేస్తుంది.
from agno.agent import Agent from agno.models.openai import OpenAIChat from agno.tools import Toolkit from agentcredia import Client agentcredia = Client() # reads AGENTCREDIA_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( agentcredia.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ని అందుకుంటే, దాన్ని పోలింగ్ చేయకుండా వెబ్‌హుక్‌తో ధృవీకరించండి. ధృవీకరించు సహాయకుడు Node SDKలో షిప్పింగ్ చేస్తుంది; ఒక Python సేవలో మీరు డాక్యుమెంటెడ్ HMACకు వ్యతిరేకంగా చేతితో ధృవీకరించాలి, ఇది సహాయకుడు చేసే అన్ని విషయాలు. కింద ఉన్న FastAPI ఉదాహరణ; అదే కోడ్ ఏ అసంక్రోనస్ Python ఫ్రేమ్‌వర్క్‌లో పనిచేస్తుంది.
import hmac, hashlib, os, time from fastapi import FastAPI, Request, HTTPException app = FastAPI() SECRET = os.environ["AGENTCREDIA_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-AgentCredia-Signature", "") ts = request.headers.get("X-AgentCredia-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-AgentCredia-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) మరియు హ్యాండ్లర్‌ను బ్లాక్ చేయకుండా వెంటనే 200 కి స్పందించండి.
మీరు ముడివేస్తున్న క్లయింట్ ఓపెన్ ఉంది. దీన్ని చదవండి.
clone చేయడానికి ప్రత్యేక Agno starter package లేదు - పై recipe నే integration. agentcredia SDKs GitHub లో open source గా ఉన్నాయి; ఈ recipe Python SDK (agentcredia-python) ను wrap చేస్తుంది, పూర్తి method surface docs లో ఉంది. toolkit methods కోసం reference గా చదవండి.
github.com/agentcredia/agentcredia-pythonపూర్తి SDK method surface మరియు scopes the docs లో documented గా ఉన్నాయి. Base Sepolia పై sk_test_ key తో start చేయండి, తర్వాత toolkit మీరు ఆశించినట్లు పనిచేసినప్పుడు sk_live_ కి switch చేయండి.
గమనించాల్సిన ఐదు Agno-సంబంధిత విషయాలు.
Agno అనేది ఇంటిగ్రేట్ చేయడానికి శుభ్రమైన ఏజెంట్ ఫ్రేమ్‌వర్క్‌లలో ఒకటి, కానీ దీనికి కొన్ని గాట్చాలు ఉన్నాయి - ప్రత్యేకంగా ఫిడేటా పేరు మార్చడం మరియు మార్క్‌డౌన్ రెండరింగ్ చుట్టూ.
Agno ప్యాకేజీ లేదు - మీరు SDKని Toolkitలో చుట్టండి
AgentCredia LangChain మరియు CrewAI కోసం అడాప్టర్లు మరియు MCP సర్వర్‌ను పంపిస్తుంది; ప్రత్యేకమైన Agno ప్యాకేజీ లేదు. పై వంటకం మార్గం: వాస్తవ agentcredia క్లయింట్‌ను కాల్ చేసే పద్ధతిని నమోదు చేసే Toolkit ఉపవర్గం. Agno పద్ధతి సంతకం మరియు డాక్స్ట్రింగ్‌ను చదివి సాధనం స్కీమాను నిర్మిస్తుంది, కాబట్టి డాక్స్ట్రింగ్ ఖచ్చితంగా ఉంచండి.
Phidata నుండి Agno మిగిలిన గందరగోళం
2024 లో Agno, Phidata నుండి పేరు మార్చుకుంది. phi.agent లేదా phi.tools నుండి import చేసే పాత codebases compatibility shim ద్వారా ఇంకా పనిచేస్తాయి, కానీ ప్రస్తుత imports agno.*. ఈ recipe మొత్తం agno.* ను ఉపయోగిస్తుంది; మీ code ఇంకా phi.* imports పై ఉంటే, Toolkit జోడించే ముందు pip install -U agno రన్ చేసి import paths మార్చండి.
Amounts USDC base units గా, strings రూపంలో
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 కు ఒక mode మాత్రమే ఎంచుకోండి - agent.run() ను call చేసి ఫలితాన్ని await చేయడానికి ప్రయత్నిస్తే, మీరు string ఆశించిన చోట coroutine వస్తుంది. Toolkit లోని agentcredia call synchronous; మీరు async path లో ఉండి ఎక్కువ volume నిర్వహిస్తే, event loop responsive గా ఉండేలా దాన్ని asyncio.to_thread తో wrap చేయండి.
వెబ్‌హుక్‌లను కచ్చితమైన శరీరానికి ధృవీకరించండి
మీ ఏజెంట్ కూడా USDCని అందుకుంటే, దాన్ని పోలింగ్ చేయకుండా వెబ్‌హుక్‌తో ధృవీకరించండి. RAW అభ్యర్థన బైట్స్‌పై సంతకం ధృవీకరించండి (await request.body()), ఎప్పుడూ request.json() పునః-సీరియలైజ్ చేయకండి, ఎందుకంటే HMAC ఖచ్చితమైన బైట్స్‌ను కవర్ చేస్తుంది. ఇది 300-సెకన్ల పునరావృత విండోతో HMAC-SHA256. కింద ఉన్న హ్యాండ్లర్ మొత్తం విషయం.