Linq.AI.OpenAI 1.2.3

There is a newer version of this package available.
See the version list below for details.
dotnet add package Linq.AI.OpenAI --version 1.2.3                
NuGet\Install-Package Linq.AI.OpenAI -Version 1.2.3                
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Linq.AI.OpenAI" Version="1.2.3" />                
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add Linq.AI.OpenAI --version 1.2.3                
#r "nuget: Linq.AI.OpenAI, 1.2.3"                
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
// Install Linq.AI.OpenAI as a Cake Addin
#addin nuget:?package=Linq.AI.OpenAI&version=1.2.3

// Install Linq.AI.OpenAI as a Cake Tool
#tool nuget:?package=Linq.AI.OpenAI&version=1.2.3                

Linq.AI.OpenAI

This library adds Linq extension methods using OpenAI structured outputs.

This library was heaviy inspired by stevenic's agentm-js library, Kudos!

Installation

dotnet add package Linq.AI.OpenAI

Architecture

For each element in a collection an model API call is made to evaluate and return the result. These are done in parallel on background threads.

OpenAI model

To use these methods you will need to instantiate a ChatClient model like this:

var model = new ChatClient(model: "gpt-4o-mini", "<modelKey>");

NOTE: The model must support structured output.

Object Extensions

These extensions use an OpenAI model to work with text.

Extension Description
.Classify()/.ClassifyAsync() classify the text using a model.
.Summarize()/.SummarizeAsync() Create a summarization for the text by using a model.
.Matches()/.MatchesAsync() Return whether the text matches using a model.
.Answer()/.AnswerAsync() get the answer to a question from the text using a model.
.Select()/.SelectAsync() Select a collection of items from the text using a model.

Object .Classify()

enum Genres { Rock, Pop, Electronica, Country, Classical };
var classification = item.Classify<Genres>(model);

item.Summarize()

var summary = item.Summarize(model, "with 3 words");

item.Matches()

if (item.Matches(model, "there is date"))
  ...

item.Answer()

var summary = text.Answer(model, "what is the birthday?");

item.Select()

Select pulls a collection of items from the source.

Example using model to select

var words = text.Select<string>(model, "The second word of every paragraph");

Example using model to select structed data.

public class HREF 
{ 
	public string Url {get;set;}
	public string Title {get;set;}
}
var summary = text.Select<HREF>(model);

Linq Extensions

These collection extensions use an OpenAI model to work with collections using Linq style methods.

Extension Description
.Where() Filter the collection of items by using a model. filter
.Select() transform the item into another format using a model.
.Remove() Remove items from a collection of items by using a model. filter
.Summarize() Create a summarization for each item by using a model.
.Classify() classify each item using a model.
.Answer() get the answer to a question for each item using a model.

NOTE: These methods internally run AI calls as throttled parallel background tasks.

enumerable.Classify()

This allows you to classify each item using a model;

enum Genres { Rock, Pop, Electronica, Country, Classical };
var classifiedItems = items.Classify<Genres>(model);

enumerable.Where()/enumerable.Remove()

Filter a collection using natural language

var breadboxItems = items.Where(model, "item would fit in a bread box");
var bigItems = items.Remove(model, "item would fit in a bread box");

enumerable.Select()

.Select() let's you transform the source into target using an OpenAI model.

You can use it to transform an object from one format to another by simply giving the types. It will use model to do the transformation.

var targetItems = items.Select<SourceItem,TargetItem>(model)

You can use it to transform a collection of text

var markdownItems = items.Select(model, "transform each item into markdown like this:\n# {{TITLE}}\n{{AUTHOR}}\n{{Description}}")

enumerable.Summarize()

Generate text summary for each item using an OpenAI model.

var summaries = items.Summarize(model);

You can control the summarization with a hint

var summaries = items.Summarize(model, "generate a 3 word summary");

enumerable.Answer()

This operator let's you ask a question for each item in a collection.

var answers = items.Answer<float>(model, "What is the cost?");

Defining new operators

All of these operators are built up of 2 core operators

  • TransformItemAsync() - which allows you to give a transformation goal and instructions for a single item.
  • TransformItems() - Which allows you a transformation goal and instructions for each element in a enumerable collection.

To create a custom operator you create an static class and define static methods for transforming an object or collection of objects.

For example, here is the implementation of Summarize():

  • The SummarizeAsync() method defines object operator which calls TransformItemAsync with a default goal of "Create a summarization" with result type of string.
  • The Summarize() method defines a collection operator which calls TransformItems with a default goal of "Create a summarization" with result type for each item in the collection of string.
    public static class SummarizeExtension
    {
        // Object operator
        public static Task<string> SummarizeAsync(this object source, ChatClient model, string? goal, string? instructions = null, CancellationToken cancellationToken = default)
            => source.TransformItemAsync<string>(model, goal ?? "create a summarization", instructions, cancellationToken);

        // collection operator
        public static IList<string> Summarize(this IEnumerable<object> source, ChatClient model, string? goal = null, string? instructions = null, int? maxParallel = null, CancellationToken cancellationToken = default)
            => source.TransformItem<string>(model, goal ?? "create a summarization", instructions, maxParallel, cancellationToken);
    }
Product Compatible and additional computed target framework versions.
.NET net8.0 is compatible.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated
2.2.1 48 12/16/2024
2.2.0 68 10/15/2024
2.1.0 60 10/11/2024
2.0.6 96 9/15/2024
2.0.5 72 9/14/2024
2.0.4 87 9/14/2024
2.0.3 60 9/14/2024
2.0.2 62 9/14/2024
2.0.1 73 9/14/2024
1.3.0 65 9/14/2024
1.2.3 64 9/13/2024
1.2.2 65 9/12/2024
1.2.1 74 9/12/2024
1.2.0 64 9/11/2024
1.1.0 66 9/11/2024
1.0.1 65 9/11/2024
1.0.0 66 9/11/2024