KnowPro.NET Updates (#1758)

* Knowledge Extraction
  * Knowledge Json Translator
  * Knowledge extraction schema
  * ActionParam parsing
  * Knowledge merging 
  * Batch extraction
* Refactoring
* Bug fixes

Author: umeshma

dotnet/typeagent/examples/knowProConsole/Includes.cs

@@ -17,6 +17,7 @@
 
 global using TypeAgent.AIClient;
 global using TypeAgent.KnowPro;
+global using TypeAgent.KnowPro.KnowledgeExtractor;
 global using TypeAgent.KnowPro.Storage.Local;
 global using TypeAgent.KnowPro.Storage.Sqlite;
 global using TypeAgent.ConversationMemory;

dotnet/typeagent/examples/knowProConsole/PodcastCommands.cs

@@ -129,14 +129,14 @@ private async Task PodcastImportIndexAsync(ParseResult args, CancellationToken c
         }
     }
 
-
     private Podcast CreatePodcast(string name, bool createNew)
     {
-        // TODO: standardize this boilerplate, esp the cache binding
-        var model = new TextEmbeddingModelWithCache(256);
-        ConversationSettings settings = new ConversationSettings(model);
-        var provider = _kpContext.CreateStorageProvider<PodcastMessage, PodcastMessageMeta>(settings, name, createNew);
-        model.Cache.PersistentCache = provider.GetEmbeddingCache();
+        MemorySettings settings = new MemorySettings();
+        var provider = _kpContext.CreateStorageProvider<PodcastMessage, PodcastMessageMeta>(
+            settings.ConversationSettings,
+            name,
+            createNew
+        );
 
         var podcast = new Podcast(settings, provider);
         return podcast;

dotnet/typeagent/examples/knowProConsole/TestCommands.cs

@@ -22,6 +22,7 @@ public IList<Command> GetCommands()
             SearchMessagesTermsDef(),
             TestEmbeddingsDef(),
             SearchQueryTermsDef(),
+            KnowledgeDef(),
             BuildIndexDef(),
         ];
     }
@@ -308,6 +309,36 @@ private async Task SearchQueryTermsAsync(ParseResult args, CancellationToken can
         KnowProWriter.WriteJson(result);
     }
 
+    private Command KnowledgeDef()
+    {
+        Command cmd = new("kpTestKnowledge")
+        {
+            Args.Arg<string>("text")
+        };
+        cmd.TreatUnmatchedTokensAsErrors = false;
+        cmd.SetAction(this.KnowledgeAsync);
+        return cmd;
+    }
+
+    private async Task KnowledgeAsync(ParseResult args, CancellationToken cancellationToken)
+    {
+        // IConversation conversation = EnsureConversation();
+
+        NamedArgs namedArgs = new NamedArgs(args);
+        var text = namedArgs.Get("text");
+        if (string.IsNullOrEmpty(text))
+        {
+            return;
+        }
+        var model = new OpenAIChatModel();
+        KnowledgeExtractor exctractor = new KnowledgeExtractor(model);
+        var result = await exctractor.ExtractAsync(text, cancellationToken);
+        if (result is not null)
+        {
+            KnowProWriter.WriteJson(result);
+        }
+    }
+
     private IConversation EnsureConversation()
     {
         return (_kpContext.Conversation is not null)

dotnet/typeagent/src/aiclient/ITextEmbeddingModel.cs

@@ -51,7 +51,7 @@ public static async Task<List<float[]>> GenerateInBatchesAsync(
 
             var embeddingChunks = await chunks.MapAsync(
                 concurrency,
-                (chunk) => model.GenerateAsync(chunk, cancellationToken),
+                model.GenerateAsync,
                 notifyProgress,
                 cancellationToken
             ).ConfigureAwait(false);
@@ -62,7 +62,7 @@ public static async Task<List<float[]>> GenerateInBatchesAsync(
         {
             return await texts.MapAsync(
                 concurrency,
-                (value) => model.GenerateAsync(value, cancellationToken),
+                model.GenerateAsync,
                 progress,
                 cancellationToken
                 ).ConfigureAwait(false);

dotnet/typeagent/src/common/Async.cs

@@ -21,9 +21,10 @@ public static class Async
     public static async Task<List<TResult>> MapAsync<T, TResult>(
         this IList<T> list,
         int concurrency,
-        Func<T, Task<TResult>> processor,
+        Func<T, CancellationToken, Task<TResult>> processor,
         Action<BatchProgress>? progress = null,
-        CancellationToken cancellationToken = default)
+        CancellationToken cancellationToken = default
+    )
     {
         ArgumentVerify.ThrowIfNullOrEmpty(list, nameof(list));
         ArgumentVerify.ThrowIfLessThanEqualZero(concurrency, nameof(concurrency));
@@ -36,7 +37,7 @@ public static async Task<List<TResult>> MapAsync<T, TResult>(
 
     private static async Task<List<TResult>> MapSequentialAsync<T, TResult>(
         IList<T> list,
-        Func<T, Task<TResult>> processor,
+        Func<T, CancellationToken, Task<TResult>> processor,
         Action<BatchProgress>? progress,
         CancellationToken cancellationToken
     )
@@ -46,7 +47,7 @@ CancellationToken cancellationToken
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            var result = await processor(list[i]);
+            var result = await processor(list[i], cancellationToken);
             results.Add(result);
             if (progress is not null)
             {
@@ -59,7 +60,7 @@ CancellationToken cancellationToken
     private static async Task<List<TResult>> MapConcurrentAsync<T, TResult>(
         IList<T> list,
         int concurrency,
-        Func<T, Task<TResult>> processor,
+        Func<T, CancellationToken, Task<TResult>> processor,
         Action<BatchProgress>? progress,
         CancellationToken cancellationToken
     )
@@ -72,7 +73,7 @@ CancellationToken cancellationToken
 
             int batchSize = Math.Min(concurrency, totalCount - startAt);
             var batch = list.Slice(startAt, batchSize);
-            var tasks = batch.Map<T, Task<TResult>>(processor);
+            var tasks = batch.Map<T, Task<TResult>>((t) => processor(t, cancellationToken));
 
             var batchResults = await Task.WhenAll(tasks);
 

dotnet/typeagent/src/common/Cache.cs

@@ -24,8 +24,8 @@ public class LRUCache<TKey, TValue> : ICache<TKey, TValue>
 {
     private readonly Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>> _index;
     private readonly LinkedList<KeyValuePair<TKey, TValue>> _itemList;
-    private readonly int _highWatermark;
-    private readonly int _lowWatermark;
+    private int _highWatermark;
+    private int _lowWatermark;
 
     public LRUCache(int maxEntries, IEqualityComparer<TKey> comparer = null)
         : this(maxEntries - 1, maxEntries, comparer)
@@ -47,7 +47,9 @@ public LRUCache(int lowWatermark, int highWatermark, IEqualityComparer<TKey> com
     }
 
     public int Count => _itemList.Count;
+
     public int HighWatermark => _highWatermark;
+
     public int LowWatermark => _lowWatermark;
 
     public event Action<KeyValuePair<TKey, TValue>> Purged;
@@ -134,6 +136,13 @@ public void Clear()
         _itemList.Clear();
     }
 
+    public void SetCount(int maxEntries)
+    {
+        _highWatermark = maxEntries;
+        _lowWatermark = maxEntries - 1;
+        Trim();
+    }
+
     void MakeMRU(LinkedListNode<KeyValuePair<TKey, TValue>> node)
     {
         _itemList.Remove(node);

dotnet/typeagent/src/common/ListExtensions.cs

@@ -130,7 +130,7 @@ public static int BinarySearchFirst<T, TSearchValue>(
         return lo;
     }
 
-    public static List<ScoredItem<T>> GetTopK<T>(this IEnumerable<ScoredItem<T>> list, int topK)
+    public static List<Scored<T>> GetTopK<T>(this IEnumerable<Scored<T>> list, int topK)
     {
         var topNList = new TopNCollection<T>(topK);
         topNList.Add(list);
@@ -144,4 +144,17 @@ public static void Fill<T>(this IList<T> list, T value, int count)
             list.Add(value);
         }
     }
+
+    public static T[] Append<T>(this T[]? list, T value)
+    {
+        if (list.IsNullOrEmpty())
+        {
+            return [value];
+        }
+
+        T[] copy = new T[list.Length + 1];
+        Array.Copy(list, copy, list.Length);
+        copy[list.Length] = value;
+        return copy;
+    }
 }

dotnet/typeagent/src/common/Retry.cs

@@ -15,6 +15,12 @@ public RetrySettings()
         JitterRange = 0.5;
     }
 
+    public RetrySettings(int maxRetries)
+    {
+        ArgumentVerify.ThrowIfLessThan(maxRetries, 1, nameof(maxRetries));
+        MaxRetries = maxRetries;
+    }
+
     public int MaxRetries { get; set; }
 
     public int RetryPauseMs { get; set; }

dotnet/typeagent/src/common/ScoredItem.cs renamed to dotnet/typeagent/src/common/Scored.cs

@@ -3,9 +3,9 @@
 
 namespace TypeAgent.Common;
 
-public struct ScoredItem<T> : IComparable<ScoredItem<T>>
+public struct Scored<T> : IComparable<Scored<T>>
 {
-    public ScoredItem(T item, double score)
+    public Scored(T item, double score)
     {
         this.Item = item;
         this.Score = score;
@@ -14,25 +14,25 @@ public ScoredItem(T item, double score)
     public T Item { get; set; }
     public double Score { get; set; }
 
-    public readonly int CompareTo(ScoredItem<T> other)
+    public readonly int CompareTo(Scored<T> other)
     {
         return this.Score.CompareTo(other.Score);
     }
 
     public override readonly string ToString() => $"{this.Score}, {this.Item}";
 
-    public static implicit operator double(ScoredItem<T> src)
+    public static implicit operator double(Scored<T> src)
     {
         return src.Score;
     }
 
-    public static implicit operator T(ScoredItem<T> src)
+    public static implicit operator T(Scored<T> src)
     {
         return src.Item;
     }
 
-    public static implicit operator ScoredItem<T>(KeyValuePair<T, double> src)
+    public static implicit operator Scored<T>(KeyValuePair<T, double> src)
     {
-        return new ScoredItem<T>(src.Key, src.Value);
+        return new Scored<T>(src.Key, src.Value);
     }
 }

dotnet/typeagent/src/common/TopNCollection.cs

@@ -5,11 +5,11 @@ namespace TypeAgent.Common;
 
 public class TopNCollection<T>
 {
-    private List<ScoredItem<T>>? _items;
+    private List<Scored<T>>? _items;
     private int _count; // Actual count, since items always ha a
     private int _maxCount;
 
-    public TopNCollection(int maxCount, List<ScoredItem<T>> buffer = null)
+    public TopNCollection(int maxCount, List<Scored<T>> buffer = null)
     {
         ArgumentVerify.ThrowIfLessThan(maxCount, 1, nameof(maxCount));
 
@@ -21,7 +21,7 @@ public TopNCollection(int maxCount, List<ScoredItem<T>> buffer = null)
 
     public int Count => _count;
 
-    public ScoredItem<T> GetTop()
+    public Scored<T> GetTop()
     {
         VerifyNotEmpty();
         return _items[1];
@@ -44,17 +44,17 @@ public void Add(T item, double score)
             }
             RemoveTop();
             _count++;
-            _items[_count] = new ScoredItem<T>(item, score);
+            _items[_count] = new Scored<T>(item, score);
         }
         else
         {
             _count++;
-            _items.Add(new ScoredItem<T>(item, score));
+            _items.Add(new Scored<T>(item, score));
         }
         UpHeap(_count);
     }
 
-    public void Add(IEnumerable<ScoredItem<T>> items)
+    public void Add(IEnumerable<Scored<T>> items)
     {
         ArgumentVerify.ThrowIfNull(items, nameof(items));
         foreach(var item in items)
@@ -68,7 +68,7 @@ public void Add(IEnumerable<ScoredItem<T>> items)
     /// Returns the sorted buffer, and clears the collection
     /// </summary>
     /// <returns></returns>
-    public List<ScoredItem<T>> ByRankAndClear()
+    public List<Scored<T>> ByRankAndClear()
     {
         if (_count == 0)
         {
@@ -98,7 +98,7 @@ private void SortDescending()
         _count = count;
     }
 
-    private ScoredItem<T> RemoveTop()
+    private Scored<T> RemoveTop()
     {
         // At the top
         var item = _items[1];
@@ -158,7 +158,7 @@ private void EnsureInitialized()
         if (_items is null)
         {
             _items = [];
-            _items.Add(new ScoredItem<T>() { Score = double.MinValue, Item = default });
+            _items.Add(new Scored<T>() { Score = double.MinValue, Item = default });
         }
     }