Purple Flea Plugins for
Semantic Kernel

Enterprise AI Meets On-Chain Finance

Microsoft Semantic Kernel powers enterprise AI applications at scale. Purple Flea's SK plugin library exposes real financial APIs as first-class KernelFunction methods — type-safe, planner-compatible, and fully observable via SK telemetry.

Install the Plugin Package

Available for both .NET and Python. Choose the package that matches your SK project.

# .NET
dotnet add package PurpleFlea.SemanticKernel

# Python
pip install purpleflea-semantic-kernel

Add Plugins to Your Kernel

Import all Purple Flea plugins in three lines. The SK Planner will automatically discover and compose them into multi-step financial workflows.

using Microsoft.SemanticKernel;
using PurpleFlea.SemanticKernel;

// Build the kernel with Azure OpenAI
var kernel = Kernel.CreateBuilder()
    .AddAzureOpenAIChatCompletion(
        deploymentName: "gpt-4o",
        endpoint: Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT"),
        apiKey: Environment.GetEnvironmentVariable("AZURE_OPENAI_KEY")
    )
    .Build();

// Import all Purple Flea plugins at once
var apiKey = Environment.GetEnvironmentVariable("PURPLE_FLEA_API_KEY");
kernel.ImportPluginFromObject(new PurpleFleasPlugin(apiKey), "PurpleFlea");

// Or import individual plugins selectively
kernel.ImportPluginFromObject(new WalletPlugin(apiKey), "Wallet");
kernel.ImportPluginFromObject(new TradingPlugin(apiKey), "Trading");
kernel.ImportPluginFromObject(new CasinoPlugin(apiKey), "Casino");
kernel.ImportPluginFromObject(new DomainsPlugin(apiKey), "Domains");

// Let the planner compose multi-step financial workflows
var planner = new HandlebarsPlanner();
var plan = await planner.CreatePlanAsync(
    kernel,
    "Create a crypto wallet, check ETH balance, then open a 10 USDC long on ETH-PERP"
);

var result = await plan.InvokeAsync(kernel);
Console.WriteLine(result);

public class WalletPlugin
{
    private readonly PurpleFleasClient _client;

    public WalletPlugin(string apiKey)
        => _client = new PurpleFleasClient(apiKey);

    [KernelFunction, Description("Create a new non-custodial BIP-39 HD wallet")]
    public async Task<WalletResult> CreateWalletAsync()
        => await _client.Wallet.CreateAsync();

    [KernelFunction, Description("Get wallet balance for a specific chain")]
    public async Task<BalanceResult> GetBalanceAsync(
        [Description("The wallet address")] string address,
        [Description("Chain: eth, btc, sol, bnb, matic, trx")] string chain = "eth")
        => await _client.Wallet.GetBalanceAsync(address, chain);

    [KernelFunction, Description("Send crypto to another address")]
    public async Task<TransactionResult> SendAsync(
        [Description("Recipient address")] string to,
        [Description("Amount in USD")] decimal amount,
        [Description("Token: USDC, ETH, BTC, SOL")] string token = "USDC")
        => await _client.Wallet.SendAsync(to, amount, token);
}

Python Semantic Kernel Integration

The Python SK package uses the same plugin pattern. Decorate methods with @kernel_function or use the pre-built plugin classes.

import asyncio
import os
import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from purpleflea_semantic_kernel import (
    WalletPlugin, TradingPlugin, CasinoPlugin, DomainsPlugin
)

async def main():
    kernel = sk.Kernel()

    # Add Azure OpenAI (or OpenAI, or any SK-compatible model)
    kernel.add_service(AzureChatCompletion(
        deployment_name="gpt-4o",
        endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
        api_key=os.environ["AZURE_OPENAI_KEY"],
    ))

    # Register Purple Flea plugins
    api_key = os.environ["PURPLE_FLEA_API_KEY"]
    kernel.add_plugin(WalletPlugin(api_key), plugin_name="wallet")
    kernel.add_plugin(TradingPlugin(api_key), plugin_name="trading")
    kernel.add_plugin(CasinoPlugin(api_key), plugin_name="casino")
    kernel.add_plugin(DomainsPlugin(api_key), plugin_name="domains")

    # Invoke a composed workflow
    result = await kernel.invoke_prompt(
        "Create a new crypto wallet, check if 'myagent.ai' is available, and register it if the price is under $50"
    )
    print(result)

asyncio.run(main())

All Available KernelFunctions

Every function is decorated with [KernelFunction] and [Description] so the SK Planner can discover and compose them automatically.

Earn Referral Commissions

Every API key carries a referral code. When agents you onboard generate activity, you earn a percentage of fees — forever, automatically.

Other Frameworks & Integrations