CrewAI ਭੁਗਤਾਨ ਇੰਟੇਗ੍ਰੇਸ਼ਨ।
CrewAI ਦੀ ਟੀਮ ਨੂੰ ਇੱਕ ਵੈਲਟ ਦਿਓ। ਇੱਕ ਸਮਰਪਿਤ ਖਜ਼ਾਨਚੀ ਏਜੰਟ USDC ਭੇਜਦਾ ਹੈ, ਇਨਵਾਇਸਾਂ ਨੂੰ ਨਿਪਟਾਉਂਦਾ ਹੈ, ਅਤੇ ਬਕਾਇਆ ਪੜ੍ਹਦਾ ਹੈ ਜਦੋਂ ਕਿ ਕੰਮ ਦੇ ਏਜੰਟ ਕੰਮ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਰਹਿੰਦੇ ਹਨ।
Blockchain0x ਇੱਕ ਅਸਲੀ 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 ਚਲਦਾ ਹੈ, ਤੁਸੀਂ ਬਿਲਕੁਲ ਜਾਣਦੇ ਹੋ ਕਿ ਕਿਹੜਾ ਏਜੰਟ ਇਸਨੂੰ ਚਲਾਉਂਦਾ ਹੈ (ਖਜ਼ਾਨਚੀ) ਅਤੇ ਇਹ ਕਿਸ ਕੰਮ ਲਈ ਸੀ (ਜੋ ਇਸਨੂੰ ਸੌਂਪਿਆ ਗਿਆ ਸੀ)। ਇਕੱਲੇ ਏਜੰਟ ਇੰਟਿਗ੍ਰੇਸ਼ਨ ਉਸ ਰੇਖਾ ਨੂੰ ਧੁੰਦਲਾ ਕਰਦੇ ਹਨ ਅਤੇ ਪ੍ਰਤੀ-ਕੰਮ ਖਰਚ ਵਿਸ਼ਲੇਸ਼ਣ ਨੂੰ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦੇ ਹਨ।
ਇੱਕ pip ਇੰਸਟਾਲ ਕਰੋ। ਇੱਕ ਵਾਤਾਵਰਣ ਚਲ।
ਇਸ package ਲਈ Python 3.10 ਜਾਂ ਇਸ ਤੋਂ ਨਵਾਂ ਵਰਜਨ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਇਹ poetry ਜਾਂ pip ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਹ core blockchain0x SDK ਅਤੇ crewai ਨੂੰ dependencies ਵਜੋਂ ਲਿਆਉਂਦਾ ਹੈ; ਹੋਰ ਕੁਝ add ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ।
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 key ਹੈ, ਅਤੇ ਇਹ adapter ਨੂੰ ਲੋੜੀਂਦੀ ਇਕੱਲੀ variable ਹੈ - ਇਹ key ਨੂੰ backend ਤੱਕ forward ਕਰਦਾ ਹੈ ਅਤੇ ਆਪਣੇ ਕੋਲ ਕੋਈ secret ਨਹੀਂ ਰੱਖਦਾ। ਹੇਠਾਂ ਦਿੱਤੇ webhook handler ਲਈ ਤੁਸੀਂ BLOCKCHAIN0X_WEBHOOK_SECRET ਵੀ set ਕਰਦੇ ਹੋ, ਜੋ dashboard webhook create ਜਾਂ rotate ਕਰਨ ਸਮੇਂ ਇਕ ਵਾਰ ਦਿੰਦਾ ਹੈ।
ਭੁਗਤਾਨ + ਖੋਜ ਭੂਮਿਕਾਵਾਂ ਨਾਲ ਇੱਕ ਕੰਮ ਕਰਦਾ ਦੋ-ਏਜੰਟ ਕ੍ਰੂ।
ਹੇਠਾਂ ਇੱਕ ਪੂਰਾ CrewAI ਕ੍ਰੂ ਹੈ ਜਿੱਥੇ ਇੱਕ ਖਜ਼ਾਨਚੀ ਏਜੰਟ ਇੱਕ ਡੇਟਾ ਵੇਂਡਰ ਨੂੰ USDC ਵਿੱਚ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਖੋਜਕਰਤਾ ਏਜੰਟ ਨਤੀਜੇ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਖਜ਼ਾਨਚੀ ਵੈਲਿਟ ਟੂਲਾਂ ਨੂੰ ਰੱਖਦਾ ਹੈ; ਖੋਜਕਰਤਾ ਕੋਈ ਨਹੀਂ ਰੱਖਦਾ। ਇਹ ਉਹ ਮਿਆਰੀ ਪੈਟਰਨ ਹੈ ਜੋ ਇੱਕ ਕ੍ਰੂ ਖਰਚ ਕਰਦਾ ਹੈ।
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 ਤੁਹਾਡੇ agent ਨੂੰ settle ਹੁੰਦਾ ਹੈ, Blockchain0x ਤੁਹਾਡੇ webhook URL 'ਤੇ ਇੱਕ signed event POST ਕਰਦਾ ਹੈ। verify helper Node SDK ਵਿੱਚ ship ਹੁੰਦਾ ਹੈ; Python service documented HMAC ਦੇ ਖਿਲਾਫ ਖੁਦ verify ਕਰਦੀ ਹੈ, ਜੋ helper ਵੀ ਕਰਦਾ ਹੈ। ਹੇਠਾਂ Flask example ਹੈ; ਉਹੀ code FastAPI ਜਾਂ ਕਿਸੇ ਵੀ Python web framework ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ।
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 ਪੰਜਾਂ ਟੂਲਾਂ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ: blockchain0x_send_payment, blockchain0x_settle_invoice, blockchain0x_get_wallet, blockchain0x_list_wallets, ਅਤੇ blockchain0x_get_transaction। ਜੇਕਰ ਇੱਕ ਕ੍ਰੂ ਨੂੰ ਸਿਰਫ਼ ਭੁਗਤਾਨ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਸਿਰਫ਼ ਇੱਕ ਫੈਕਟਰੀ ਨਾਲ ਦੇਵੋ।
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 ਵਿਸ਼ਲੇਸ਼ਣ ਦੇ ਵਿਚਕਾਰ ਪੈਸਾ ਚਲਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ। ਸਾਫ਼ ਪੈਟਰਨ ਇੱਕ ਸਮਰਪਿਤ ਖਜ਼ਾਨਚੀ ਏਜੰਟ ਹੈ ਜੋ ਟੂਲਾਂ ਨੂੰ ਰੱਖਦਾ ਹੈ ਅਤੇ ਆਪਣੇ ਕੰਮ ਵਜੋਂ ਚਲਾਉਂਦਾ ਹੈ; ਕੰਮ ਦੇ ਏਜੰਟਾਂ ਕੋਲ ਕੋਈ ਵਾਲਿਟ ਪਹੁੰਚ ਨਹੀਂ ਹੁੰਦੀ। ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਉਸ ਆਕਾਰ ਨੂੰ ਪਾਲਦੀ ਹੈ। ਇਸਨੂੰ ਕਾਪੀ ਕਰੋ।
ਕ੍ਰਮਬੱਧ ਵਿਰੁੱਧ ਹਾਇਰਾਰਕੀਕ ਪ੍ਰਕਿਰਿਆਵਾਂ
CrewAI ਅਨੁਕ੍ਰਮਿਕ (ਡਿਫਾਲਟ) ਅਤੇ ਹਾਇਰਾਰਕੀਕਲ ਕਾਰਵਾਈ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਹਾਇਰਾਰਕੀਕਲ ਨਾਲ, ਇੱਕ ਮੈਨੇਜਰ ਏਜੰਟ ਕ੍ਰੂ ਨੂੰ ਸੰਗਠਿਤ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਮੈਨੇਜਰ ਨੂੰ ਵਾਲਿਟ ਟੂਲਾਂ ਨੂੰ ਸੌਂਪਣ ਦੀ ਆਗਿਆ ਹੈ, ਤਾਂ ਇਹ ਉਹਨਾਂ ਨੂੰ ਕਿਸੇ ਵੀ ਅਧੀਨ ਨੂੰ ਦੇ ਸਕਦਾ ਹੈ, ਜੋ ਕਿ ਖਰਚ ਕਰਨ ਦੀ ਅਧਿਕਾਰ ਲਈ ਤੁਸੀਂ ਨਹੀਂ ਚਾਹੁੰਦੇ। ਜਾਂ ਤਾਂ ਟੂਲਾਂ ਨੂੰ ਇੱਕ ਸਮਰਪਿਤ ਏਜੰਟ 'ਤੇ ਰੱਖੋ ਅਤੇ ਅਨੁਕ੍ਰਮਿਕ ਚਲਾਓ, ਜਾਂ ਮੈਨੇਜਰ ਦੇ ਸੌਂਪਣ ਦੇ ਨਿਯਮਾਂ ਨੂੰ ਸੀਮਿਤ ਕਰੋ।
ਕਾਮ ਦੇ ਸੰਦਰਭ ਤੋਂ ਸੈਟਲਮੈਂਟ ਦੀ ਸਥਿਤੀ ਪੜ੍ਹਨਾ
Inbound settlement ਅਸਿੰਕ੍ਰੋਨਸ ਹੈ। ਜੇ ਖੋਜ ਕਾਰਜ ਆਪਣੇ ਸੰਦਰਭ ਵਿੱਚ ਭੁਗਤਾਨ ਕਾਰਜ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਦਾ ਹੈ (ਠੀਕ ਹੈ) ਪਰ LLM ਫਿਰ ਉਸ ਸੰਦਰਭ ਤੋਂ ਆਖਰੀ ਭੁਗਤਾਨ ਦੀ ਸਥਿਤੀ ਪੜ੍ਹਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ (ਠੀਕ ਨਹੀਂ, ਪੁਸ਼ਟੀ ਬਾਅਦ ਵਿੱਚ webhook ਦੁਆਰਾ ਆਉਂਦੀ ਹੈ), ਤਾਂ ਤੁਹਾਨੂੰ ਗੜਬੜ ਆਉਟਪੁੱਟ ਮਿਲਦਾ ਹੈ। ਡਾਊਨਸਟ੍ਰੀਮ ਕੰਮ ਨੂੰ webhook-ਚਾਲਿਤ ਸਿਗਨਲ 'ਤੇ ਗੇਟ ਕਰੋ, ਕਾਰਜ ਸੰਦਰਭ 'ਤੇ ਨਹੀਂ। 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.
Webhook ਹੈਂਡਲਰ ਕ੍ਰੂ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਬਾਹਰ
ਤੁਹਾਡਾ webhook ਹੈਂਡਲਰ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਵੱਖਰਾ Flask ਜਾਂ FastAPI ਪ੍ਰਕਿਰਿਆ ਹੁੰਦਾ ਹੈ, ਜੋ ਕਿ ਕ੍ਰੂ ਰਨਟਾਈਮ ਦਾ ਹਿੱਸਾ ਨਹੀਂ ਹੁੰਦਾ। ਕ੍ਰੂ ਆਪਣੀ kickoff() ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ ਅਤੇ ਵਾਪਸ ਆਉਂਦਾ ਹੈ; webhook ਬਾਅਦ ਵਿੱਚ ਆਉਂਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਭੁਗਤਾਨ ਨਿਪਟਦਾ ਹੈ। ਦੋਹਾਂ ਨੂੰ ਇੱਕ ਕਿਊ ਜਾਂ ਡੇਟਾਬੇਸ ਰੋਅ ਨਾਲ ਜੋੜੋ ਜੋ webhook ਲਿਖਦਾ ਹੈ ਅਤੇ ਕ੍ਰੂ ਆਪਣੇ ਅਗਲੇ ਚਲਾਉਣ 'ਤੇ ਪੜ੍ਹਦਾ ਹੈ। ਕਿਸੇ ਵੀ webhook ਦੀ ਉਡੀਕ ਕਰਦੇ ਹੋਏ ਕ੍ਰੂ ਨੂੰ ਜੀਵੰਤ ਨਾ ਰੱਖੋ - CrewAI ਚਲਾਉਣ ਡਿਜ਼ਾਈਨ ਦੁਆਰਾ ਛੋਟੇ ਹੁੰਦੇ ਹਨ।