Add supported payment workflows to CrewAI.
CrewAI ક્રૂને એક વોલેટ આપો. એક સમર્પિત ખજાનચી એજન્ટ USDC મોકલે છે, ઇન્વોઈસ નિકાલ કરે છે, અને બેલેન્સ વાંચે છે જ્યારે કાર્ય એજન્ટો કાર્ય પર કેન્દ્રિત રહે છે.
AgentCredia એક વાસ્તવિક Python package, , શિપ કરે છે. તેને install કરો, set કરો, call કરો, અને tools dedicated treasurer agent ને આપો. તે agent USDC મોકલી શકે છે, on-chain proof સાથે invoice settle કરી શકે છે, અને wallets વાંચી શકે છે, જ્યારે crewના work agents પાસે wallet access હોતું નથી. USDC Base પર settle થાય છે.
CrewAIની શક્તિ ભૂમિકા વિભાજન છે. તેને વોલેટ માટે પણ ઉપયોગ કરો.
અન્ય ફ્રેમવર્ક દરેક સાધનને એક જ એજન્ટ પર મૂકે છે. CrewAI નું ડિઝાઇન ભૂમિકા વિભાજનને પ્રોત્સાહન આપે છે: એક સંશોધક સંશોધન કરે છે, એક લેખક લખે છે, એક સમીક્ષક સમીક્ષા કરે છે. પૈસાને સમાન વ્યવહારની જરૂર છે - એક સમર્પિત ખજાનચી એજન્ટ વૉલેટ સાધનો ધરાવે છે, અને કાર્ય એજન્ટો પાસે કોઈ નથી. ખર્ચ કરવાની અધિકાર એક જ જગ્યાએ રહે છે તેના બદલે કે ક્રૂમાં જે કોઈપણ એજન્ટ છે તેમાંથી લીક થાય.
આ આકાર પણ ઓડિટ પાથને વધુ સ્પષ્ટ બનાવે છે. જ્યારે USDC ખસેડાય છે, ત્યારે તમે જાણો છો કે કયા એજન્ટે તેને ખસેડ્યું (ખજાનચી) અને તે કયા કાર્ય માટે હતું (જેને handed off કર્યું). એકલ એજન્ટ એકીકરણો તે રેખાને ધૂળવાડે છે અને પ્રતિ કાર્ય ખર્ચ વિશ્લેષણને મુશ્કેલ બનાવે છે.
એક પિપ ઇન્સ્ટોલ. એક પર્યાવરણ ચલ.
પેકેજને પાયથન 3.10 અથવા નવા આવશ્યક છે અને કવિતા અથવા પિપ સાથે કાર્ય કરે છે. તે મુખ્ય agentcredia SDK અને crewai ને નિર્ભરતા તરીકે ખેંચે છે; વધુ કંઈ ઉમેરવાની જરૂર નથી.
pip install agentcredia-crewaiexport AGENTCREDIA_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
AGENTCREDIA_API_KEY તમારા AgentCredia dashboardમાંથી મળતી sk_test_ testnet અથવા sk_live_ mainnet key છે, અને adapterને જરૂરી એકમાત્ર variable એ જ છે - તે keyને backend તરફ ફોરવર્ડ કરે છે અને પોતાનું કોઈ secret રાખતું નથી. નીચેના webhook handler માટે તમારે AGENTCREDIA_WEBHOOK_SECRET પણ સેટ કરવું પડશે, જે webhook create અથવા rotate કરતાં dashboard એકવાર આપે છે.
ચલતું બે-એજન્ટ ક્રૂ જે બિલિંગ + સંશોધન ભૂમિકા ધરાવે છે.
નીચે એક સંપૂર્ણ CrewAI ક્રૂ છે જ્યાં એક ખજાનચી એજન્ટ USDCમાં ડેટા વેંડરને ચૂકવે છે, અને એક સંશોધક એજન્ટ પરિણામનો ઉપયોગ કરે છે. ખજાનચી પાસે વોલેટ સાધનો છે; સંશોધક પાસે કોઈ નથી. આ એજન્ટો માટે ખર્ચ કરનારા ક્રૂ માટેનો માનક પેટર્ન છે.
from crewai import Agent, Task, Crew from agentcredia import Client from agentcredia_crewai import create_agentcredia_toolset client = Client() # reads AGENTCREDIA_API_KEY from the environment tools = create_agentcredia_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 an AgentCredia 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 agentcredia_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 તમારા એજન્ટ પર સેટલ થાય છે, AgentCredia તમારા વેબહુક URL પર સહી કરેલ ઇવેન્ટ પોસ્ટ કરે છે. માન્યતા હેલ્પર નોડ SDKમાં શિપ થાય છે; એક Python સેવા દસ્તાવેજિત HMAC સામે હાથથી ચકાસે છે, જે હેલ્પર કરે છે તે બધું છે. નીચે Flask ઉદાહરણ; તે જ કોડ FastAPI અથવા કોઈપણ Python વેબ ફ્રેમવર્કમાં કાર્ય કરે છે.
import hmac, hashlib, os, time from flask import Flask, request, abort app = Flask(__name__) SECRET = os.environ["AGENTCREDIA_WEBHOOK_SECRET"].encode() @app.post("/webhooks/payment") def receive(): raw = request.get_data() # RAW bytes - do not parse first sig = request.headers.get("X-AgentCredia-Signature", "") ts = request.headers.get("X-AgentCredia-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-AgentCredia-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_agentcredia_toolset પાંચેય tools પાછાં આપે છે: agentcredia_send_payment, agentcredia_settle_invoice, agentcredia_get_wallet, agentcredia_list_wallets, અને agentcredia_get_transaction. જો crew ને માત્ર ચુકવણી કરવાની જરૂર હોય, તો તેને એક જ factory સાથે માત્ર એ એક જ આપો.
from agentcredia_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 આધાર એકમો છે, સ્ટ્રિંગ્સ તરીકે
agentcredia_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.
Webhook હેન્ડલર ક્રૂ પ્રક્રિયા બહાર
તમારો વેબહુક હેન્ડલર સામાન્ય રીતે એક અલગ Flask અથવા FastAPI પ્રક્રિયા છે, ક્રૂ રનટાઇમનો ભાગ નથી. ક્રૂ તેની kickoff() પૂર્ણ કરે છે અને પાછું આવે છે; જ્યારે ચુકવણી સેટલ થાય ત્યારે વેબહુક પછી આવે છે. queued અથવા ડેટાબેસની પંક્તિ સાથે બંનેને બ્રિજ કરો જે વેબહુક લખે છે અને ક્રૂ તેની આગામી રન પર વાંચે છે. વેબહુકની રાહ જોતા ક્રૂને જીવંત રાખતા નથી - CrewAI રન ડિઝાઇન દ્વારા ટૂંકા જીવનવાળા છે.