સેમેન્ટિક કર્નલ ચુકવણી એકીકરણ.
કોઈ Semantic Kernel પેકેજની જરૂર નથી. વાસ્તવિક blockchain0x ક્લાયન્ટને KernelFunction (Python અથવા Java) માં લપેટો, અથવા C# KernelFunction માંથી REST APIને કોલ કરો. બંને રીતે એજન્ટ Base પર USDC ખસેડે છે.
કોઈ સેમેન્ટિક કર્નલ પેકેજ નથી. પાયથનમાં તમે વાસ્તવિક blockchain0x ક્લાયન્ટને @kernel_function સાથે સજ્જ પદ્ધતિમાં લપેટો છો; C# માં, જ્યાં કોઈ .NET SDK મોકલવામાં આવતું નથી, એક [KernelFunction] સીધો REST API કૉલ કરે છે. તેને તમારા કર્નલ પર નોંધણી કરો, FunctionChoiceBehavior ને Auto પર સેટ કરો, અને એજન્ટ Base પર USDC ખસેડી શકે છે. મોકલવામાં આવેલા મુખ્ય SDKs છે નોડ, પાયથન, રૂબી, ગો, અને JVM.
એકમાત્ર એન્ટરપ્રાઇઝ-ગ્રેડ .NET એજન્ટ ફ્રેમવર્ક.
જો તમારું સ્ટેક માઇક્રોસોફ્ટ-આકારનું છે (એઝ્યુર, .NET, SQL સર્વર, ટીમો, કોપાઇલોટ સ્ટુડિયો), તો સેમેન્ટિક કર્નેલ લગભગ ચોક્કસપણે યોગ્ય એજન્ટ ફ્રેમવર્ક છે. તે માઇક્રોસોફ્ટ દ્વારા બનાવવામાં આવ્યું છે, તે એઝ્યુર ઓપનએઆઈ, AKS, અને એન્ટ્રા સાથે એકીકૃત થાય છે, અને તે .NET, પાયથન, અને જાવામાં પ્રથમ-શ્રેણીની સપોર્ટ આપે છે જે અન્ય કોઈ ફ્રેમવર્ક સાથે મેળ ખાતું નથી. અને તે તમને જે જરૂર છે તે પહેલાથી જ આપે છે: એક KernelFunction ફક્ત એક પદ્ધતિ છે, તેથી ચુકવણીઓમાં વાયરિંગ એ એક પદ્ધતિ છે જે તમે લખો છો, ન કે એક પેકેજ જે માટે તમે રાહ જુઓ છો.
આ જ કારણ છે કે ઇન્સ્ટોલ કરવા માટે કોઈ સેમેન્ટિક કર્નલ એડેપ્ટર નથી. પાયથન અને જાવામાં તમે વાસ્તવિક blockchain0x SDK ને KernelFunctionમાં લપેટો છો; C# માં, જ્યાં કોઈ .NET SDK હજુ જહાજ નથી, KernelFunction સીધા HttpClient સાથે REST APIને કૉલ કરે છે. તમે આદર્શ એર્ગોનોમિક્સ જાળવતા હો - શણગારવાળા પદ્ધતિઓ, અસંક્રામક, ગુણધર્મ આધારિત પેરામિટર માન્યતા - અને ટ્રેક કરવા માટે કોઈ એડેપ્ટર સંસ્કરણ નથી. આજના મુખ્ય SDKs છે નોડ, પાયથન, રૂબી, ગો, અને JVM.
Semantic Kernel સ્થાપિત કરો અને, Python માં, મુખ્ય SDK.
જોડવા માટે કોઈ blockchain0x સેમેન્ટિક કર્નલ પેકેજ નથી. પાયથન સેમેન્ટિક કર્નલ અને વાસ્તવિક blockchain0x SDKને ઇન્સ્ટોલ કરે છે; C# Microsoft.SemanticKernel ને ઇન્સ્ટોલ કરે છે અને બિલ્ટ-ઇન HttpClient સાથે REST APIને કૉલ કરે છે. જાવા સેમેન્ટિક કર્નલ માટે જાવા અને com.blockchain0x:sdk-jvm SDK નો ઉપયોગ કરે છે.
pip install semantic-kernel blockchain0xdotnet add package Microsoft.SemanticKernelBLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet BLOCKCHAIN0X_API_KEY=sk_test_... # same key, the name the .NET REST example reads OPENAI_API_KEY=sk-...
BLOCKCHAIN0X_API_KEY (Python ક્લાયન્ટ આને વાંચે છે) તમારા ડેશબોર્ડમાંથી મળતી sk_test_ testnet અથવા sk_live_ mainnet કી છે; C# REST ઉદાહરણ એ જ value BLOCKCHAIN0X_API_KEYમાંથી વાંચે છે. OPENAI_API_KEY (અથવા Azure-hosted models માટે AZURE_OPENAI_*) તમારી LLM key છે. webhook handler ને વધારામાં BLOCKCHAIN0X_WEBHOOK_SECRETની જરૂર પડે છે.
એક વોલેટ KernelFunction, Python અને C# માં.
Python વાસ્તવિક blockchain0x ક્લાયન્ટને @kernel_function થી શણગારેલ પદ્ધતિમાં લપેટે છે. C#, જ્યાં કોઈ .NET SDK શિપ નથી, એક [KernelFunction] ને બહાર પાડે છે જે સીધા HttpClient સાથે POST /v1/payments ને કૉલ કરે છે. બંને વૉલેટ તરીકે Kernel પર નોંધણી કરે છે.send_usdc; ફક્ત આસપાસની સમારંભ ભિન્ન છે.
from semantic_kernel import Kernel from semantic_kernel.functions import kernel_function from blockchain0x import Client blockchain0x = Client() # reads BLOCKCHAIN0X_API_KEY from the environment class WalletPlugin: @kernel_function(description="Send a USDC payment from an agent wallet.") def send_usdc(self, agent_id: str, to: str, amount_wei: str) -> str: # amount_wei is USDC base units (6 decimals): "10000" = 0.01 USDC return str( blockchain0x.payments.create(body={"agentId": agent_id, "to": to, "amountWei": amount_wei}) ) kernel = Kernel() kernel.add_plugin(WalletPlugin(), plugin_name="Wallet") # Add your chat service, then let the model call Wallet.send_usdc.
using System.ComponentModel;
using System.Net.Http.Json;
using Microsoft.SemanticKernel;
// There is no .NET SDK, so a C# KernelFunction calls the REST API directly.
public class WalletPlugin
{
private static readonly HttpClient Http = new()
{
BaseAddress = new Uri("https://api.blockchain0x.com"),
};
[KernelFunction, Description("Send a USDC payment from an agent wallet. amountWei is USDC base units (6 decimals).")]
public async Task<string> SendUsdc(string agentId, string to, string amountWei)
{
Http.DefaultRequestHeaders.Authorization =
new("Bearer", Environment.GetEnvironmentVariable("BLOCKCHAIN0X_API_KEY"));
var res = await Http.PostAsJsonAsync("/v1/payments", new { agentId, to, amountWei });
return await res.Content.ReadAsStringAsync();
}
}
// builder.Plugins.AddFromType<WalletPlugin>("Wallet");Register the function on the kernel, set FunctionChoiceBehavior to Auto, and when the user's message implies a payment the model calls Wallet.send_usdc with the agent id, recipient, and amount. amountWei is base units, so 0.01 USDC is "10000". The Python path returns the SDK result; the C# path returns the REST response body.
ચુકવણી ઘટનાઓ પ્રાપ્ત કરવા માટે ASP.NET કોર મિનિમલ API.
જ્યારે ચુકવણી સેટલ થાય છે, Blockchain0x તમારા વેબહુક URL પર સહી કરેલ ઇવેન્ટ પોસ્ટ કરે છે. ત્યાં કોઈ શિપ કરેલ .NET ચકાસક નથી, તેથી હેન્ડલર દસ્તાવેજિત HMAC સામે હાથથી ચકાસે છે - જે હેલ્પર કરશે તે બધું છે. નીચે .NET ઉદાહરણ; Python અને Java તેમના પોતાના HMAC લાઇબ્રેરીઓ સાથે સમાન રીતે ચકાસે છે.
using System.Security.Cryptography;
using System.Text;
using Microsoft.AspNetCore.Builder;
var app = WebApplication.CreateBuilder(args).Build();
var secret = Environment.GetEnvironmentVariable("BLOCKCHAIN0X_WEBHOOK_SECRET")!;
app.MapPost("/webhooks/payment", async (HttpRequest req) =>
{
using var reader = new StreamReader(req.Body);
var raw = await reader.ReadToEndAsync(); // RAW body - verify before parsing
var sig = req.Headers["X-Blockchain0x-Signature"].ToString();
var ts = req.Headers["X-Blockchain0x-Timestamp"].ToString();
var parts = sig.Split(',').Select(p => p.Split('=', 2))
.Where(p => p.Length == 2).ToDictionary(p => p[0], p => p[1]);
var t = parts.GetValueOrDefault("t", ts);
var v1 = parts.GetValueOrDefault("v1", sig);
var want = Convert.ToHexString(new HMACSHA256(Encoding.UTF8.GetBytes(secret))
.ComputeHash(Encoding.UTF8.GetBytes($"{t}.{raw}"))).ToLowerInvariant();
var fresh = Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - long.Parse(t)) <= 300;
if (!fresh || !CryptographicOperations.FixedTimeEquals(
Encoding.UTF8.GetBytes(want), Encoding.UTF8.GetBytes(v1)))
return Results.Unauthorized();
if (req.Headers["X-Blockchain0x-Event-Type"] == "payment.received")
await RunFollowupAsync(); // USDC landed - do the next step
return Results.Ok();
});
app.Run();અલ્ગોરિધમ t.rawBody પર HMAC-SHA256 છે, 300-સેકન્ડનું પુનરાવર્તન વિન્ડો, અને એક સ્થિર-સમયની તુલના. સહી અક્ષુણ રહે તે માટે StreamReader દ્વારા કાચી બોડી વાંચો; ડેસિરિયલાઇઝ પછી ફરીથી-સિરિયલાઇઝ ન કરો. શિપ કરેલ ઇવેન્ટ્સ છે payment.received, payment.sent, wallet.deployed, અને webhook.test. ઉત્પાદનમાં વેબહૂક ઘણીવાર એજન્ટ સાથે ડેટાબેસને શેર કરતી અલગ ASP.NET કોર સેવા તરીકે ચાલે છે જેથી બંને સમન્વયિત થઈ શકે.
SDKs અને REST સપાટી ખુલ્લી છે. તેમને વાંચો.
ક્લોન કરવા માટે કોઈ Semantic Kernel starter package નથી - ઉપરના recipes જ integration છે. blockchain0x core SDKs (Node, Python, Ruby, Go) GitHub પર open source છે, અને તેમની method surface સાથે C# ઉદાહરણ જે REST routes call કરે છે તે docsમાં documented છે.
docs.blockchain0x.com/docs/overviewSDK method surface અને REST routes the docsમાં documented છે. Base Sepolia સામે sk_test_ keyથી શરૂ કરો, પછી KernelFunction અપેક્ષા મુજબ કામ કરે ત્યારે sk_live_ પર switch કરો.
પાંચ Semantic Kernel-વિશિષ્ટ જાળાઓથી બચવું.
સેમેન્ટિક કર્નલનું પ્લગિન મોડેલ સ્વચ્છ છે પરંતુ તેમાં ક્રોસ-ભાષા અને વર્તન-ડિફોલ્ટ ગોટચા છે. તેમને આગળથી જાણવું સમય બચાવે છે.
કોઈ સેમેન્ટિક કર્નલ પેકેજ નથી, કોઈપણ ભાષામાં
કોઈ NuGet, PyPI, અથવા Maven એડેપ્ટર નથી. મોકલવામાં આવેલા મુખ્ય SDKs છે નોડ, પાયથન, રૂબી, ગો, અને JVM - .NET નથી. તેથી પાયથન કર્નલ blockchain0x પાયથન ક્લાયન્ટને @kernel_function માં લપેટે છે, જાવા કર્નલ com.blockchain0x:sdk-jvm SDK નો ઉપયોગ કરે છે, અને C# કર્નલ એક KernelFunction (ઉપર બતાવેલ) માંથી સીધો REST API કૉલ કરે છે. ત્રણેય થોડા પંક્તિઓ છે.
FunctionChoiceBehavior આપમેળે હોવું જોઈએ
સેમેન્ટિક કર્નલ ફક્ત પ્લગિન ફંક્શનને આમંત્રણ આપે છે જ્યારે FunctionChoiceBehaviorને પ્રોમ્પ્ટ-એક્શન સેટિંગ્સ પર ઓટો પર સેટ કરવામાં આવે છે. ડિફોલ્ટ નન છે, તેથી મોડેલ ક્યારેય તમારા વોલેટ ફંક્શનને કૉલ કરતું નથી ભલે જ વપરાશકર્તા કેટલાય સ્પષ્ટ રીતે પૂછે. જો એજન્ટ સંપૂર્ણપણે ફંક્શનને અવગણાવે છે, તો પહેલા આ તપાસો.
રકમ USDC આધાર એકમો છે, સ્ટ્રિંગ્સ તરીકે
The payments call takes amountWei: a string of USDC base units (6 decimals), so 0.01 USDC is "10000" and 5 USDC is "5000000". Type the function argument as a string in any language. payments.create 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.
એજન્ટો વચ્ચે પ્લગઇન વ્યાપકતા
ખર્ચ કરવાની અધિકાર ધરાવતી એજન્ટના કર્નલ પર જ વૉલેટ કાર્યને નોંધણી કરો. પ્લગઇન વૈશ્વિક નથી - એક એજન્ટ જેનું કર્નલ તેને નથી ધરાવતું તે તેને કૉલ કરી શકતું નથી. સમીક્ષક એજન્ટને વૉલેટ કાર્ય વિના કર્નલ આપો, અથવા પ્રતિ એજન્ટ મંજૂર કરેલ કાર્યને મર્યાદિત કરો, જેથી પૈસો એક ભૂમિકા સાથે રહે.
કાચા બોડી સામે વેબહુક્સની પુષ્ટિ કરો
કાચા વિનંતી બોડીને વાંચો અને ડેસીરિયલાઇઝ કરતા પહેલા ચકાસો - HMAC ચોક્કસ બાઇટ્સને આવરી લે છે, તેથી એક પાર્શ-ત્યારે-ફિરથી સીરિયલાઇઝ રાઉન્ડ ટ્રિપ તેને તોડે છે. નીચેનું .NET હેન્ડલર દસ્તાવેજિત અલ્ગોરિધમને અમલમાં લાવે છે: HMAC-SHA256 પર t.rawBody, 300-સેકન્ડની વિન્ડો, અને સ્થિર-સમયની તુલના. Python અને Java તેમના પોતાના HMAC લાઇબ્રેરીઓ સાથે સમાન રીતે ચકાસે છે.