സെമാന്റിക് കർണൽ പേയ്മെന്റ് ഇന്റഗ്രേഷൻ.
Semantic Kernel പാക്കേജ് ആവശ്യമില്ല. യഥാർത്ഥ blockchain0x ക്ലയന്റിനെ KernelFunction (Python അല്ലെങ്കിൽ Java) ൽ മൂടുക, അല്ലെങ്കിൽ C# KernelFunction ൽ നിന്ന് REST API-യെ വിളിക്കുക. എങ്ങനെ ആയാലും ഏജന്റ് Base-ൽ USDC നീക്കുന്നു.
Semantic Kernel പാക്കേജ് ഇല്ല. Python-ൽ നിങ്ങൾ യഥാർത്ഥ blockchain0x ക്ലയന്റിനെ @kernel_function-ൽ അലങ്കരിച്ച ഒരു രീതിയിൽ മൂടുന്നു; C#-ൽ, .NET SDK അയക്കുന്നില്ല, [KernelFunction] നേരിട്ട് REST API-യെ വിളിക്കുന്നു. നിങ്ങളുടെ കർണലിൽ അത് രജിസ്റ്റർ ചെയ്യുക, FunctionChoiceBehavior Auto-ൽ സജ്ജീകരിക്കുക, കൂടാതെ ഏജന്റ് Base-ൽ USDC നീക്കാൻ കഴിയും. അയച്ച കോർ SDK-കൾ Node, Python, Ruby, Go, JVM എന്നിവയാണ്.
ഏകദേശം സംരംഭ-തരം .NET ഏജന്റ് ഫ്രെയിംവർക്കാണ്.
നിങ്ങളുടെ സ്റ്റാക്ക് Microsoft-ആകൃതിയിലുള്ളവയാണെങ്കിൽ (Azure, .NET, SQL Server, Teams, Copilot Studio), Semantic Kernel ശരാശരി ഏജന്റ് ഫ്രെയിംവർക്കാണ്. ഇത് Microsoft-ൽ നിർമ്മിച്ചതാണ്, Azure OpenAI, AKS, Entra എന്നിവയുമായി സംയോജിപ്പിക്കുന്നു, കൂടാതെ മറ്റ് ഏതെങ്കിലും ഫ്രെയിംവർക്കുകൾക്ക് തുല്യമായ രീതിയിൽ .NET, Python, Java എന്നിവയിൽ ആദ്യക്ലാസ് പിന്തുണ നൽകുന്നു. ഇത് നിങ്ങൾക്ക് ആവശ്യമുള്ളതും നൽകുന്നു: ഒരു KernelFunction ഒരു രീതിയാണ്, അതിനാൽ പണമിടപാടുകൾ കണക്ട് ചെയ്യുന്നത് നിങ്ങൾ എഴുതുന്ന ഒരു രീതിയാണ്, നിങ്ങൾ കാത്തിരിക്കുന്ന ഒരു പാക്കേജ് അല്ല.
ഇത് ഇൻസ്റ്റാൾ ചെയ്യാൻ സെമാന്റിക് കർണൽ അഡാപ്റ്റർ ഇല്ലാത്തതിനാൽ ആണ്. Python-ൽ, Java-യിൽ നിങ്ങൾ KernelFunction-ൽ യഥാർത്ഥ blockchain0x SDK വ്രാപ്പ് ചെയ്യുന്നു; C#-ൽ, .NET SDK ഇനിയും എത്തുന്നില്ല, KernelFunction REST API-യെ HttpClient ഉപയോഗിച്ച് നേരിട്ട് വിളിക്കുന്നു. നിങ്ങൾ ശൈലിയിലുള്ള എർഗോണോമിക്സ് നിലനിർത്തുന്നു - അലങ്കൃതമായ രീതികൾ, അസിങ്ക്, അറ്റ്രിബ്യൂട്ട് അടിസ്ഥാനപരമായ പാരാമീറ്റർ സ്ഥിരീകരണം - കൂടാതെ ട്രാക്ക് ചെയ്യാൻ ഒരു അഡാപ്റ്റർ പതിപ്പ് ഇല്ല. ഇന്ന് നിലവിലുള്ള പ്രധാന SDK-കൾ Node, Python, Ruby, Go, JVM എന്നിവയാണ്.
Semantic Kernel ഇൻസ്റ്റാൾ ചെയ്യുക, കൂടാതെ Python-ൽ, കോർ SDK.
ചേർക്കാൻ blockchain0x Semantic Kernel പാക്കേജ് ഇല്ല. Python Semantic Kernel-നെ യഥാർത്ഥ blockchain0x SDK-യോടൊപ്പം ഇൻസ്റ്റാൾ ചെയ്യുന്നു; C# Microsoft.SemanticKernel-നെ ഇൻസ്റ്റാൾ ചെയ്യുന്നു, встроенный HttpClient ഉപയോഗിച്ച് REST API-യെ വിളിക്കുന്നു. Java Semantic Kernel for Java-യെ 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 client ഇത് വായിക്കുന്നു) നിങ്ങളുടെ dashboard-ലുള്ള sk_test_ testnet അല്ലെങ്കിൽ sk_live_ mainnet കീ ആണ്; C# REST example അതേ 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 എന്ന അലങ്കാരമുള്ള ഒരു രീതിയിൽ ചുറ്റുന്നു. .NET SDK വിതരണം ചെയ്യുന്നില്ലാത്ത C#-ൽ, HttpClient-നൊപ്പം POST /v1/payments നേരിട്ട് വിളിക്കുന്ന [KernelFunction] ഉള്പ്പെടുത്തുന്നു. ഇരുവരും Wallet.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-ലേക്ക് ഒപ്പിട്ട ഇവന്റ് POST ചെയ്യുന്നു. അയച്ച .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 കോർ സേവനമായി പ്രവർത്തിക്കുന്നു, അതിനാൽ രണ്ടും ഏകോപിപ്പിക്കാം.
SDK-കളും REST ഉപരിതലവും തുറന്നതാണ്. അവ വായിക്കുക.
clone ചെയ്യാൻ വേറെ Semantic Kernel starter package ഇല്ല - മുകളിലെ recipes തന്നെയാണ് integration. blockchain0x core SDKs (Node, Python, Ruby, Go) GitHub-ൽ open source ആണ്, കൂടാതെ അവയുടെ method surface ഉം C# example വിളിക്കുന്ന REST routes ഉം docs-ൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട്.
docs.blockchain0x.com/docs/overviewSDK method surface ഉം REST routes ഉം the docs ൽ രേഖപ്പെടുത്തിയിരിക്കുന്നു. Base Sepolia-യിൽ sk_test_ key ഉപയോഗിച്ച് ആരംഭിക്കുക, തുടർന്ന് KernelFunction നിങ്ങൾ പ്രതീക്ഷിക്കുന്നതു പോലെ പ്രവർത്തിക്കുമ്പോൾ sk_live_ ആയി മാറുക.
എടുപ്പിക്കേണ്ട അഞ്ചു Semantic Kernel-നിഷ്ഠമായ തട്ടിപ്പുകൾ.
സെമാന്റിക് കർണലിന്റെ പ്ലഗിൻ മോഡൽ ശുദ്ധമാണ്, എന്നാൽ ഭാഷാ ക്രോസ്-ലാംഗ്വേജ്, പെരുമാറ്റ-ഡിഫോൾട്ട് ഗോട്ട്ചാസ് ഉണ്ട്. അവയെ മുൻകൂട്ടി അറിയുന്നത് സമയം ലാഭിക്കുന്നു.
ഏതെങ്കിലും ഭാഷയിൽ Semantic Kernel പാക്കേജ് ഇല്ല
NuGet, PyPI, അല്ലെങ്കിൽ Maven അഡാപ്റ്റർ ഇല്ല. അയച്ച കോർ SDK-കൾ Node, Python, Ruby, Go, JVM എന്നിവയാണ് - .NET അല്ല. അതിനാൽ Python കർണൽ blockchain0x Python ക്ലയന്റിനെ @kernel_function-ൽ മൂടുന്നു, Java കർണൽ com.blockchain0x:sdk-jvm SDK ഉപയോഗിക്കുന്നു, C# കർണൽ KernelFunction-ൽ നിന്ന് നേരിട്ട് REST API-യെ വിളിക്കുന്നു (മുകളിൽ കാണിച്ചിരിക്കുന്നു). മൂന്ന് വരികളാണ്.
FunctionChoiceBehavior ഓട്ടോ ആയിരിക്കണം
Semantic Kernel ഫംഗ്ഷൻചോയിസ് ബിഹേവിയർ പ്രോംപ്റ്റ്-എക്സിക്യൂഷൻ സജ്ജീകരണങ്ങളിൽ ഓട്ടോ ആയി ക്രമീകരിക്കുമ്പോൾ മാത്രമേ പ്ലഗിൻ ഫംഗ്ഷനുകൾ വിളിക്കുകയുള്ളു. ഡിഫാൾട്ട് None ആണ്, അതിനാൽ ഉപയോക്താവ് എത്ര വ്യക്തമായി ചോദിച്ചാലും മോഡൽ നിങ്ങളുടെ വാലറ്റ് ഫംഗ്ഷൻ വിളിക്കുകയില്ല. ഏജന്റ് ഫംഗ്ഷനെ മുഴുവൻ അവഗണിച്ചാൽ, ആദ്യം ഇത് പരിശോധിക്കുക.
അളവുകൾ 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 ലൈബ്രറികളുമായി ഒരുപോലെ സ്ഥിരീകരിക്കുന്നു.