This blog base from C# version https://github.com/microsoft/semantic-kernel/blob/main/dotnet/samples/GettingStarted/Step8_Pipelining.cs
F# code is here https://github.com/rocklau/fsharpPlayground
Introducing F# with Semantic Kernel: Simplifying AI App Development with the Pipeline Pattern
As developers, we are continuously looking for tools and frameworks that can help us streamline our workflows and build efficient applications. In the realm of AI app development, Microsoft's Semantic Kernel (SK) has emerged as a powerful framework to simplify the integration of AI capabilities into applications. Coupling this with the functional programming prowess of F#, we can create robust, maintainable, and scalable AI solutions. Today, we'll explore how to harness the pipeline pattern in F# with SK to develop AI apps more easily.
Why F# and Semantic Kernel?
F# is a functional-first programming language that empowers developers to write concise, expressive, and high-performance code. It shines in scenarios requiring complex data manipulations, asynchronous programming, and domain-specific languages (DSLs).
Semantic Kernel, on the other hand, is a developer kit from Microsoft designed to enable rapid embedding of AI functionalities within applications. It abstracts many complexities associated with AI model integration and provides a range of tools for building intelligent systems effortlessly.
Combining F# with Semantic Kernel allows us to leverage the pipeline pattern, a well-known functional programming construct, to process data through a sequence of operations seamlessly. Let's delve into the practical implementation of this approach.
Implementing the Pipeline Pattern
Here's a step-by-step guide on how to implement a simple pipeline pattern using F# and Semantic Kernel.
1. Define Custom Types and Functions
First, we set up our custom types and essential functions. We define a JsonValue type to represent different JSON structures and a JsonSchema type for schema validation.
type JsonValue =
| JsonObject of Map<string, JsonValue>
| JsonArray of JsonValue list
| JsonString of string
| JsonNumber of float
| JsonBool of bool
| JsonNull
type JsonSchema =
| SchemaObject of Map<string, JsonSchema>
| SchemaArray of JsonSchema
| SchemaString
| SchemaNumber
| SchemaBool
| SchemaNull
| SchemaRequired of JsonSchema
Next, we define a context type and a result type to handle the outcomes of our operations:
type Context = { Input: JsonElement }
type Result<'T> =
| Success of 'T
| Failure of string
2. JSON Value Conversion and Validation
We then create functions to convert JSON elements to our JsonValue types and validate JSON against schemas:
let rec toJsonValue (jsonElement: JsonElement): JsonValue =
match jsonElement.ValueKind with
| JsonValueKind.Object ->
jsonElement.EnumerateObject()
|> Seq.map (fun prop -> prop.Name, toJsonValue prop.Value)
|> Map.ofSeq
|> JsonObject
| JsonValueKind.Array ->
jsonElement.EnumerateArray()
|> Seq.map toJsonValue
|> List.ofSeq
|> JsonArray
| JsonValueKind.String -> JsonString (jsonElement.GetString())
| JsonValueKind.Number -> JsonNumber (jsonElement.GetDouble())
| JsonValueKind.True -> JsonBool true
| JsonValueKind.False -> JsonBool false
| JsonValueKind.Null -> JsonNull
| _ -> failwith "Unsupported JSON value kind"
let rec validateJson (schema: JsonSchema) (json: JsonValue): bool =
match schema, json with
| SchemaObject properties, JsonObject obj ->
properties |> Map.forall (fun key valueSchema ->
match obj.TryFind key with
| Some value -> validateJson valueSchema value
| None -> valueSchema <> SchemaRequired _)
| SchemaArray itemSchema, JsonArray items ->
items |> List.forall (validateJson itemSchema)
| SchemaString, JsonString _
| SchemaNumber, JsonNumber _
| SchemaBool, JsonBool _
| SchemaNull, JsonNull -> true
| SchemaRequired innerSchema, value -> validateJson innerSchema value
| _ -> false
3. Creating Contexts and JSON Operations
We create functions to build contexts and perform JSON operations like addition, multiplication, and squaring:
let createContextWithNewValue newValue =
let json = JsonDocument.Parse($"{{ \"value\": {newValue} }}").RootElement
{ Input = json }
let jsonOperation opFunc (context: Context) : Result<Context> =
try
let value = context.Input.GetProperty("value").GetInt32()
let newValue = opFunc value
Success (createContextWithNewValue newValue)
with
| ex -> Failure ex.Message
let addOne = jsonOperation ((+) 1)
let multiplyByTwo = jsonOperation ((*) 2)
let square = jsonOperation (fun x -> x * x)
4. Mapping Functions and Defining the Pipeline
We map function names to actual functions and define our pipeline function which processes data through these functions:
let functionMap =
[ "addOne", addOne
"multiplyByTwo", multiplyByTwo
"square", square ]
|> Map.ofList
let toFunction name : Context -> Result<Context> =
match Map.tryFind name functionMap with
| Some func -> func
| None -> fun _ -> Failure (sprintf "Function %s not found" name)
let pipeline schema context functions =
match validateSchema schema context with
| Failure msg -> Failure msg
| Success validatedContext ->
functions
|> Array.fold (fun acc funcName ->
match acc with
| Failure msg -> Failure msg
| Success ctx -> toFunction funcName ctx) (Success validatedContext)
5. Implementing and Testing the Pipeline
Finally, we implement and test our pipeline:
let schemaJson = SchemaObject (Map.ofList [ ("value", SchemaRequired SchemaNumber) ])
let initialContext = createContextWithNewValue 3
let functionNames = [| "addOne"; "multiplyByTwo"; "square" |]
let resultContext = pipeline schemaJson initialContext functionNames
match resultContext with
| Success ctx -> printfn "Result: %s" (ctx.Input.ToString())
| Failure msg -> printfn "Error: %s" msg
Integrating with Semantic Kernel
To make our AI app more realistic, we integrate it with the Semantic Kernel by creating a plugin and utilizing OpenAI models:
type Calculate() =
[<KernelFunction>]
[<Description("")>]
member this.Pipeline([<Description("input number")>] input:int , [<Description("choose from addOne multiplyByTwo square")>] functionNames:string[] ) =
let schemaJson = SchemaObject (Map.ofList [ ("value", SchemaRequired SchemaNumber) ])
let initialContext = createContextWithNewValue input
let resultContext = pipeline schemaJson initialContext functionNames
match resultContext with
| Success ctx -> sprintf "Result: %s" (ctx.Input.ToString())
| Failure msg -> sprintf "Error: %s" msg
let key = "sk-"
let model = "gpt-4o-mini"
let chat_url ="https://api.openai.com/v1/chat/completions"
let builder = Kernel.CreateBuilder().AddOpenAIChatCompletion(modelId = model, endpoint = Uri(chat_url), apiKey = key)
let plugins = builder.Plugins.AddFromType<Calculate>()
let kernel = builder.Build()
asyncEx {
let settings = OpenAIPromptExecutionSettings()
settings.ToolCallBehavior <- ToolCallBehavior.AutoInvokeKernelFunctions
let arguments = new KernelArguments(settings)
printfn "Plugins count : %d" kernel.Plugins.Count
let! response2 = kernel.InvokePromptAsync("Calculate: input 3 to Pipeline [addOne addOne]", arguments)
Console.WriteLine(response2)
} |> Async.RunSynchronously |> ignore
Conclusion
By leveraging the power of F# and the versatility of Semantic Kernel, we can create AI applications following the pipeline pattern efficiently. This combination not only simplifies our development process but also ensures our applications are maintainable, scalable, and robust. Whether you're new to F# or Semantic Kernel, diving into this pattern can significantly enhance your ability to build sophisticated AI solutions with minimal complexity. Happy coding!
Top comments (0)