CrewAI പേയ്മെന്റ് ഇന്റഗ്രേഷൻ.
CrewAI ക്രൂയ്ക്ക് ഒരു വാലറ്റ് നൽകുക. ഒരു സമർപ്പിത ട്രഷറർ ഏജന്റ് USDC അയക്കുന്നു, ഇൻവോയിസുകൾ പരിഹരിക്കുന്നു, ജോലി ഏജന്റുകൾ ജോലി ചെയ്യുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുമ്പോൾ ബാലൻസുകൾ വായിക്കുന്നു.
Blockchain0x ഒരു യഥാർത്ഥ Python package, , നൽകുന്നു. ഇത് install ചെയ്യുക, സജ്ജീകരിക്കുക, വിളിക്കുക, തുടർന്ന് tools ഒരു dedicated treasurer agent-ന് നൽകുക. ആ agent-ിന് USDC അയയ്ക്കാനും, on-chain proof ഉപയോഗിച്ച് invoice settle ചെയ്യാനും, wallets വായിക്കാനും കഴിയും, എന്നാൽ ടീമിലെ work agents-ന് wallet access ഉണ്ടാകില്ല. USDC Base-ൽ settle ചെയ്യുന്നു.
CrewAI-യുടെ ശക്തി വേഷം വേർതിരിക്കലാണ്. ഇത് വാലറ്റിനും ഉപയോഗിക്കുക.
മറ്റു ഫ്രെയിംവർക്ക് ഓരോ ഉപകരണം ഒരു ഏക ഏജന്റിൽ കെട്ടിടം ചെയ്യുന്നു. CrewAI-ന്റെ രൂപകൽപ്പന പങ്കുവെക്കൽ പ്രോത്സാഹിപ്പിക്കുന്നു: ഒരു ഗവേഷകൻ ഗവേഷണം നടത്തുന്നു, ഒരു എഴുത്തുകാരൻ എഴുതുന്നു, ഒരു അവലോകനക്കാരൻ അവലോകനം ചെയ്യുന്നു. പണം സമാനമായ പരിചരണം അർഹിക്കുന്നു - ഒരു സമർപ്പിത ട്രഷറർ ഏജന്റ് വാലറ്റ് ഉപകരണങ്ങൾ കൈവശം വഹിക്കുന്നു, ജോലി ഏജന്റുകൾ ഒന്നും കൈവശം വഹിക്കുന്നില്ല. ചെലവിന്റെ അധികാരം ഒരു സ്ഥലത്ത് നിലനിൽക്കുന്നു, ക്രൂയിൽ ഉണ്ടായിട്ടുള്ള ഓരോ ഏജന്റിലും പുറത്ത് വിടുന്നില്ല.
ഈ രൂപം ഓഡിറ്റ് പാതകൾ കൂടുതൽ വ്യക്തമായതാക്കുന്നു. USDC നീങ്ങുമ്പോൾ, നിങ്ങൾക്ക് അത് എവിടെ നീക്കിയ ഏജന്റ് (വിതരണക്കാരൻ) എവിടെയെന്ന് കൃത്യമായി അറിയാം, അത് ഏത് ജോലിക്ക് (അത് കൈമാറിയവൻ) ആയിരുന്നു. ഏക-ഏജന്റ് സംയോജനം ആ വരി മങ്ങിയതാക്കുന്നു, ഓരോ ജോലിക്കുള്ള ചെലവിന്റെ വിശകലനത്തെ കൂടുതൽ കഠിനമാക്കുന്നു.
ഒരു പിപ്പ് ഇൻസ്റ്റാൾ. ഒരു പരിസ്ഥിതി വ്യത്യാസം.
പാക്കേജിന് Python 3.10 അല്ലെങ്കിൽ പുതിയതും ആവശ്യമാണ്, ഇത് കവിത അല്ലെങ്കിൽ പിപ്പ് ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു. ഇത് പ്രധാന blockchain0x SDK, crewai എന്നിവയെ ആശ്രയിക്കുന്നു; മറ്റൊന്നും ചേർക്കേണ്ടതില്ല.
pip install blockchain0x-crewaiexport BLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
BLOCKCHAIN0X_API_KEY നിങ്ങളുടെ Blockchain0x dashboard-ലുള്ള sk_test_ testnet അല്ലെങ്കിൽ sk_live_ mainnet കീ ആണ്, adapter-ിന് ആവശ്യമായ ഏക variable അതാണ് - അത് key backend-ലേക്ക് forward ചെയ്യുന്നു, സ്വതന്ത്ര secret ഒന്നും സൂക്ഷിക്കുന്നില്ല. താഴെ ഉള്ള webhook handler-ിന് നിങ്ങൾ BLOCKCHAIN0X_WEBHOOK_SECRET കൂടി set ചെയ്യണം, ഇത് ഒരു webhook create ചെയ്യുമ്പോഴോ rotate ചെയ്യുമ്പോഴോ dashboard ഒരിക്കൽ return ചെയ്യും.
പണമടയ്ക്കലും ഗവേഷണവും ഉള്ള രണ്ട് ഏജന്റുമാരുടെ പ്രവർത്തനശീലമായ സംഘം.
താഴെ ഒരു പൂർണ്ണമായ CrewAI ക്രൂവാണ്, ഒരു ട്രഷർ ഏജന്റ് USDC-യിൽ ഒരു ഡാറ്റ വിൽപ്പനക്കാരനോട് പണമിടപാട് ചെയ്യുന്നു, ഒരു ഗവേഷകൻ ഏജന്റ് ഫലത്തെ ഉപയോഗിക്കുന്നു. ട്രഷർ വാലറ്റ് ഉപകരണങ്ങൾ കൈവശം വയ്ക്കുന്നു; ഗവേഷകൻ ഒന്നും കൈവശം വയ്ക്കുന്നില്ല. ഇത് ചെലവഴിക്കുന്ന ഒരു ക്രൂവിന് canonical മാതൃകയാണ്.
from crewai import Agent, Task, Crew from blockchain0x import Client from blockchain0x_crewai import create_blockchain0x_toolset client = Client() # reads BLOCKCHAIN0X_API_KEY from the environment tools = create_blockchain0x_toolset(client) # A dedicated treasurer holds the wallet tools; the work agents do not. treasurer = Agent( role="Treasurer", goal="Pay vendor invoices in USDC within owner-set limits", backstory="Operates a Blockchain0x agent wallet on Base.", tools=tools, allow_delegation=False, ) researcher = Agent( role="Senior Market Analyst", goal="Produce a thorough Q4 LLM market analysis", backstory="A specialist analyst with 10 years in tech-market research.", tools=[], allow_delegation=False, ) pay_task = Task( description="Pay 0.01 USDC from our agent wallet to the data vendor at 0xVendor.", expected_output="The transaction hash of the settled payment.", agent=treasurer, ) research_task = Task( description="Using the purchased dataset, write the Q4 LLM market analysis.", expected_output="A 1,500-word market analysis.", agent=researcher, context=[pay_task], ) crew = Crew(agents=[treasurer, researcher], tasks=[pay_task, research_task]) result = crew.kickoff()
When you call crew.kickoff(), the pay_task runs first: the treasurer calls blockchain0x_send_payment, the SDK submits the transfer on Base, and the transaction hash is the task output. The research_task runs next and uses the purchased result. amount_wei is USDC base units, so 0.01 USDC is the string "10000". On a sk_test_ key the whole flow runs on Base Sepolia, and payments.create can answer 503 until the chain adapter is wired for your network.
ഒരു കൈമാറ്റം എത്തുമ്പോൾ അടുത്ത ക്രൂയെ ഉണർത്തുന്നു.
USDC നിങ്ങളുടെ ഏജന്റിലേക്ക് നിശ്ചയിക്കുമ്പോൾ, Blockchain0x നിങ്ങളുടെ വെബ്ഹുക്ക് URL-ലേക്ക് ഒപ്പിട്ട ഇവന്റ് POST ചെയ്യുന്നു. verify സഹായകം Node SDK-ൽ അയക്കുന്നു; ഒരു Python സേവനം രേഖപ്പെടുത്തിയ HMAC-യുടെ എതിരായ കൈയൊപ്പിൽ സ്ഥിരീകരിക്കുന്നു, അത് സഹായകൻ ചെയ്യുന്നതാണ്. താഴെ Flask ഉദാഹരണം; സമാനമായ കോഡ് FastAPI-യിൽ അല്ലെങ്കിൽ ഏതെങ്കിലും Python വെബ് ഫ്രെയിംവർക്ക്-ൽ പ്രവർത്തിക്കുന്നു.
import hmac, hashlib, os, time from flask import Flask, request, abort app = Flask(__name__) SECRET = os.environ["BLOCKCHAIN0X_WEBHOOK_SECRET"].encode() @app.post("/webhooks/payment") def receive(): raw = request.get_data() # RAW bytes - do not parse first sig = request.headers.get("X-Blockchain0x-Signature", "") ts = request.headers.get("X-Blockchain0x-Timestamp", "") # Header is "t=<unix>,v1=<hex>"; some proxies send bare hex + the ts header. 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: abort(401) if request.headers.get("X-Blockchain0x-Event-Type") == "payment.received": run_followup_for(request.get_json()) # USDC landed - do the work return "ok", 200
ഇത് യഥാർത്ഥ ആൽഗോരിതം: HMAC-SHA256 t.rawBody എന്ന സ്ട്രിംഗിൽ, ഒരു സ്ഥിരമായ സമയം താരതമ്യം, 300-സെക്കൻഡ് പുനരാവൃത വിൻഡോ. കച്ചവട ശരീരത്തെ വായിക്കുക (request.get_data()), request.get_json() വീണ്ടും സീരിയലൈസ് ചെയ്യരുത്, കാരണം അത് ഒപ്പിടുന്നവയെ ഉൾക്കൊള്ളുന്ന ബൈറ്റുകൾ മാറ്റുന്നു. ആർക്കിടെക്ചർ: ഹാൻഡ്ലർ ഒരു ജോലിയെ എൻക്യൂ ചെയ്യാൻ (Celery, RQ, Redis പട്ടിക) അനുവദിക്കുക, അത് CrewAI യാഥാർത്ഥ്യ പ്രവർത്തനം ഉണർത്തുന്നു. ഹാൻഡ്ലറിന്റെ ഉള്ളിൽ crew.kickoff() വിളിക്കുന്നത് മിനിറ്റുകൾ എടുക്കാം, HTTP അഭ്യർത്ഥന സമയം തീരുന്നു.
ക്രൂക്ക് മുഴുവൻ ഉപകരണങ്ങൾ കൈമാറുക, അല്ലെങ്കിൽ ഒരു ഉപകരണം മാത്രം.
create_blockchain0x_toolset എല്ലാ അഞ്ച് tools-ഉം തിരികെ നൽകുന്നു: blockchain0x_send_payment, blockchain0x_settle_invoice, blockchain0x_get_wallet, blockchain0x_list_wallets, మరియు blockchain0x_get_transaction. ഒരു crew-യ്ക്ക് പണം അടയ്ക്കാൻ മാത്രമേ ആവശ്യമുള്ളൂ എങ്കിൽ, single factory ഉപയോഗിച്ച് അതിൽ അതൊന്നേ നൽകൂ.
from blockchain0x_crewai import create_payment_tool pay = create_payment_tool(client) # amount_wei is USDC base units: 6 decimals, so 10000 = 0.01 USDC. pay.run(agent_id="agt_123", to="0xRecipient", amount_wei="10000")
per-capability factories ആണ് create_payment_tool, create_invoice_tool, create_wallet_tool, create_wallets_list_tool, 그리고 create_transaction_tool. Source ഉം testnet examples ഉം the Python SDK repo ൽ ലഭ്യമാണ്; CrewAI support matrix the docs ൽ ആണ്.
ഒരു ക്രൂയിൽ ബില്ലിംഗ് വയറിങ്ങ് ചെയ്യുമ്പോൾ ശ്രദ്ധിക്കേണ്ട അഞ്ചു കാര്യങ്ങൾ.
CrewAI-യുടെ റോള്ബേസ്ഡ് ഡിസൈൻ മറ്റുള്ള ഫ്രെയിംവർക്കുകളേക്കാൾ പേയ്മെന്റ് ഇന്റഗ്രേഷൻ കൂടുതൽ ശുദ്ധമാക്കുന്നു. ഇതിന് സ്വന്തമായ പാദവായ്പ്പുകൾ ഉണ്ട്. ഇവ മുൻകൂട്ടി അറിയുന്നത് സമയം ലാഭിക്കുന്നു.
തെറ്റായ ഏജന്റിൽ വാലറ്റ് ഉപകരണങ്ങൾ വെക്കുന്നു
CrewAI ഏജന്റുകൾക്ക് വേഷങ്ങൾ ഉണ്ട്. വാലറ്റ് ഉപകരണങ്ങൾ ഗവേഷകനായ വ്യക്തിക്ക് കൈമാറുക, അവൻ ഗവേഷണം നടത്തേണ്ടതാണ്, LLM വിശകലനത്തിന്റെ ഇടയിൽ പണം മാറ്റാൻ ശ്രമിക്കുന്നു. ശുദ്ധമായ മാതൃക ഒരു സമർപ്പിത ട്രഷർ ഏജന്റാണ്, ഉപകരണങ്ങൾ കൈവശം വയ്ക്കുകയും അതിന്റെ സ്വന്തം ജോലി ആയി പ്രവർത്തിക്കുകയും ചെയ്യുന്നു; ജോലി ഏജന്റുകൾക്ക് വാലറ്റ് ആക്സസ് ഇല്ല. മുകളിൽ നൽകിയ ഉദാഹരണം ആ രൂപത്തിൽ തുടരുന്നു. അതിനെ പകർന്നു നൽകുക.
ക്രമാനുസൃത vs പദവിക്രമ പ്രക്രിയകൾ
CrewAI ക്രമീകരണ (ഡിഫോൾട്ട്) மற்றும் പദവീകൃത പ്രവർത്തനം പിന്തുണയ്ക്കുന്നു. പദവീകൃതതയിൽ, ഒരു മാനേജർ ഏജന്റ് ക്രൂയെ ക്രമീകരിക്കുന്നു. മാനേജർ വാലറ്റ് ഉപകരണങ്ങൾ കൈമാറാൻ അനുവദിക്കുകയാണെങ്കിൽ, അത് ഏതെങ്കിലും കീഴ്വഴക്കത്തിന് കൈമാറാൻ കഴിയും, ഇത് ചെലവു അധികാരത്തിനായി നിങ്ങൾക്ക് വേണ്ടതല്ല. ഉപകരണങ്ങൾ ഒരു സമർപ്പിത ഏജന്റിൽ സൂക്ഷിക്കുക, ക്രമീകരണത്തിൽ പ്രവർത്തിക്കുക, അല്ലെങ്കിൽ മാനേജറുടെ കൈമാറൽ നിയമങ്ങൾ നിയന്ത്രിക്കുക.
ടാസ്ക് കോൺടക്സ്റ്റിൽ നിന്ന് സെറ്റിൽമെന്റ് നില വായിക്കുന്നു
വരവായ പരിഹാരം അസിങ്ക്രണസ് ആണ്. ഗവേഷണ പ്രവർത്തനം പണമിടപാട് പ്രവർത്തനം അതിന്റെ സാഹചര്യത്തിൽ പട്ടികയിലുണ്ടെങ്കിൽ (ശ്രേഷ്ഠം) എന്നാൽ LLM പിന്നീട് ആ സാഹചര്യത്തിൽ നിന്ന് ഒരു അന്തിമ പണമിടപാട് നില വായിക്കാൻ ശ്രമിക്കുന്നു (ശ്രേഷ്ഠമല്ല, സ്ഥിരീകരണം പിന്നീട് വെബ്ഹുക്ക് വഴി എത്തുന്നു), നിങ്ങൾക്കു മഞ്ഞപ്പൊടി ഔട്ട്പുട്ട് ലഭിക്കുന്നു. താഴത്തെ പ്രവർത്തനം ഒരു വെബ്ഹുക്ക്-പ്രേരിത സിഗ്നലിൽ ഗേറ്റ് ചെയ്യുക, പ്രവർത്തനത്തിന്റെ സാഹചര്യത്തിൽ അല്ല. CrewAI-യുടെ പ്രവർത്തന കാൾബാക്കുകൾ ശരിയായ ഹുക്ക് ആണ്.
അളവുകൾ USDC അടിസ്ഥാന യൂണിറ്റുകൾ, സ്ട്രിംഗുകളായി
blockchain0x_send_payment takes amount_wei: a string of USDC base units, not a float and not a dollar figure. USDC has 6 decimals, so 0.01 USDC is "10000". CrewAI passes tool inputs through as-is, so a Python float arrives as a float and the SDK rejects it - but the error reads like a CrewAI tool error, which throws off first integrators. Pass a string.
ക്രൂ പ്രോസസിന്റെ പുറത്തുള്ള വെബ്ഹുക്ക് കൈകാര്യം ചെയ്യുന്നു
നിങ്ങളുടെ വെബ്ഹുക്ക് ഹാൻഡ്ലർ സാധാരണയായി ഒരു വ്യത്യസ്ത Flask അല്ലെങ്കിൽ FastAPI പ്രക്രിയയാണ്, ക്രൂ റൺടൈമിന്റെ ഭാഗമല്ല. ക്രൂ അതിന്റെ kickoff() പൂർത്തിയാക്കുന്നു, തിരിച്ചു വരുന്നു; ഒരു പേയ്മെന്റ് തീരുമ്പോൾ വെബ്ഹുക്ക് പിന്നീട് എത്തുന്നു. വെബ്ഹുക്ക് എഴുതുന്ന ഒരു ക്യൂ അല്ലെങ്കിൽ ഡാറ്റാബേസ് വരിയിലൂടെ ഇരുവരെയും ബന്ധിപ്പിക്കുക, ക്രൂ അടുത്ത റൺ ചെയ്യുമ്പോൾ വായിക്കുന്നു. വെബ്ഹുക്ക് കാത്തിരിക്കാൻ ഒരു ക്രൂ ജീവനോടെ സൂക്ഷിക്കരുത് - CrewAI പ്രവർത്തനങ്ങൾ രൂപകൽപ്പന പ്രകാരം ചെറുതാണ്.