408 lines
11 KiB
C#
408 lines
11 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.ServiceModel;
|
|
using System.Text;
|
|
using AICore.Prompt.Factories;
|
|
using BeWo.Data.Access;
|
|
using BeWo.Data.Entities;
|
|
using BeWo.Data.Security;
|
|
using BeWo.Service.Core;
|
|
using BeWo.Service.DCEntityMapper;
|
|
using BeWo.Service.Invoicing;
|
|
using BeWo.Service.ServiceContracts;
|
|
using BeWo.Service.ServiceProxy;
|
|
using BS.Shared;
|
|
using BS.Shared.Core;
|
|
using BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BS.Shared.DataContracts.Feature.AI;
|
|
using BS.Shared.Extensions;
|
|
using Newtonsoft.Json;
|
|
|
|
namespace BeWo.Service.Plugins
|
|
{
|
|
public class AiService2
|
|
{
|
|
// Was wird alles benötigt:
|
|
// - WebConfig
|
|
// - DBs
|
|
|
|
// ======================[ Config ]======================
|
|
public AiConfigDC GetAiConfig()
|
|
{
|
|
var configs = DAOFactory.GenericDAO.GetAllActive<AiConfig>();
|
|
|
|
var config = configs.FirstOrDefault();
|
|
|
|
if (config == null)
|
|
{
|
|
config = getDefaultAiConfig();
|
|
|
|
DAOFactory.GenericDAO.Insert(config);
|
|
}
|
|
|
|
var config_dc = MapperFactory.AiConfig.MapToNewDC(config);
|
|
|
|
return config_dc;
|
|
}
|
|
public AiConfigDC UpdateAiConfig(AiConfigDC toUpdate)
|
|
{
|
|
if (toUpdate?.Oid is null)
|
|
throw new InvalidOperationException();
|
|
|
|
var oid = toUpdate.Oid.Value;
|
|
var entity = DAOFactory.GenericDAO.LoadByID<AiConfig>(oid);
|
|
var update = MapperFactory.AiConfig.MergeWithEntity(toUpdate, entity);
|
|
|
|
DAOFactory.GenericDAO.Update(update);
|
|
|
|
var dc = MapperFactory.AiConfig.MapToNewDC(update);
|
|
|
|
return dc;
|
|
}
|
|
|
|
// ======================[ Models ]======================
|
|
public IEnumerable<AiModelDC> GetAiModels()
|
|
{
|
|
var models = getAiModels();
|
|
|
|
return MapperFactory.AiModel.MapToNewDCs(models);
|
|
}
|
|
|
|
|
|
// ======================[ Conversations ]======================
|
|
public IEnumerable<AiConversationDC> GetAiConversations(int uicontext, long? oid)
|
|
{
|
|
// SearchDAO
|
|
var current_user = UserRightHelper.GetLoggedInUserWithOid();
|
|
var convs = DAOFactory.GenericDAO.GetAllActive<AiConversation>();
|
|
|
|
var filter = new List<AiConversation>();
|
|
foreach (var conv in convs)
|
|
{
|
|
if (conv.UIContext != uicontext)
|
|
continue;
|
|
|
|
if (conv.ApplicationUserOid != current_user.Oid)
|
|
continue;
|
|
|
|
if (oid is long ref_oid)
|
|
{
|
|
var main_ref_obj = conv.ContextBeWoObjects?.FirstOrDefault();
|
|
|
|
// ServiceRecord
|
|
if (uicontext == 19)
|
|
main_ref_obj = conv.ContextBeWoObjects.FirstOrDefault(x => x.Tid == TableID.SupportConcept);
|
|
|
|
if (main_ref_obj?.Oid != ref_oid)
|
|
continue;
|
|
}
|
|
|
|
filter.Add(conv);
|
|
}
|
|
|
|
var dcs = MapperFactory.AiConversation.MapToNewDCs(filter);
|
|
|
|
return dcs;
|
|
}
|
|
|
|
public AiConversationDC CreateAiConversation(AiConversationDC conversation, long modell_oid)
|
|
{
|
|
var config = GetAiConfig();
|
|
|
|
var conv = createAiConversation(conversation.UIContext, conversation.ContextBeWoObjects, modell_oid, config.Context_Type);
|
|
|
|
var conv_dc = MapperFactory.AiConversation.MapToNewDC(conv);
|
|
|
|
return conv_dc;
|
|
}
|
|
public AiConversationDC CreateAiConversationWithMessage(AiConversationDC conversation, long modell_oid, string message)
|
|
{
|
|
var config = GetAiConfig();
|
|
|
|
var conv = createAiConversation(conversation.UIContext, conversation.ContextBeWoObjects, modell_oid, config.Context_Type);
|
|
|
|
var new_messages = sendNewMessage(conv, message, config);
|
|
|
|
var conv_dc = MapperFactory.AiConversation.MapToNewDC(conv);
|
|
|
|
return conv_dc;
|
|
}
|
|
public AiConversationDC CloneAiConversation(long conversation_oid, long? last_message_oid)
|
|
{
|
|
var parent_conv = DAOFactory.GenericDAO.GetByID<AiConversation>(conversation_oid);
|
|
|
|
if (parent_conv is null)
|
|
throw new InvalidOperationException("conv_oid unknown");
|
|
|
|
var clone_conv = new AiConversation();
|
|
|
|
clone_conv.Created = DateTime.Now;
|
|
clone_conv.ContextBeWoObjects = parent_conv.ContextBeWoObjects.ToList();
|
|
clone_conv.Displayname = "Klon von " + parent_conv.Displayname;
|
|
clone_conv.Messages = new List<AiConversationMessage>();
|
|
clone_conv.Modell = parent_conv.Modell;
|
|
clone_conv.UIContext = parent_conv.UIContext;
|
|
clone_conv.Updated = DateTime.Now;
|
|
clone_conv.ApplicationUserOid = parent_conv.ApplicationUserOid;
|
|
|
|
if (last_message_oid is null)
|
|
last_message_oid = parent_conv.Messages[0].Oid;
|
|
|
|
foreach (var msg in parent_conv.Messages)
|
|
{
|
|
var clone_msg = new AiConversationMessage();
|
|
|
|
clone_msg.Created = msg.Created;
|
|
clone_msg.Message = msg.Message;
|
|
clone_msg.Role = msg.Role;
|
|
clone_msg.Duration = msg.Duration;
|
|
clone_msg.ModelName = msg.ModelName;
|
|
|
|
clone_conv.Messages.Add(clone_msg);
|
|
clone_msg.AiConversation = clone_conv;
|
|
|
|
if (msg.Oid == last_message_oid)
|
|
break;
|
|
}
|
|
|
|
DAOFactory.GenericDAO.Insert(clone_conv);
|
|
|
|
var dc = MapperFactory.AiConversation.MapToNewDC(clone_conv);
|
|
|
|
return dc;
|
|
}
|
|
|
|
public long UpdateAiConversationDisplayname(long oid, long version, string displayname)
|
|
{
|
|
var conv = DAOFactory.GenericDAO.GetByID<AiConversation>(oid);
|
|
|
|
ServiceLogic.ConcurrencyCheck(version, conv);
|
|
|
|
conv.Displayname = displayname;
|
|
|
|
DAOFactory.GenericDAO.Update(conv);
|
|
|
|
return conv.Version.Value;
|
|
}
|
|
|
|
public void DeleteAiConversation(long conversation_oid)
|
|
{
|
|
var conversation = DAOFactory.GenericDAO.LoadByID<AiConversation>(conversation_oid);
|
|
|
|
DAOFactory.GenericDAO.SetActivationType(conversation, ActivationTypeId.Deleted);
|
|
}
|
|
|
|
// ======================[ Conversationmessages ]======================
|
|
public AiConversationMessageDC[] SendNewMessage(long conversation, string message)
|
|
{
|
|
var conv = DAOFactory.GenericDAO.LoadByID<AiConversation>(conversation);
|
|
|
|
return sendNewMessage(conv, message);
|
|
}
|
|
|
|
|
|
// ======================[ private ]======================
|
|
private AiConfig getDefaultAiConfig()
|
|
{
|
|
var config = new AiConfig();
|
|
|
|
config.Temperature = 1;
|
|
config.Top_P = 1;
|
|
config.Max_Gen_Len = 1000;
|
|
config.SelectedModel = getDefaultAiModel();
|
|
|
|
return config;
|
|
}
|
|
private AiModel getDefaultAiModel()
|
|
{
|
|
var models = getAiModels();
|
|
|
|
if (models == null || !models.Any())
|
|
return null;
|
|
|
|
var llama = models.Where(x => x.ModelName.Contains("llama3.2"));
|
|
|
|
if (llama.Any())
|
|
return llama.First();
|
|
|
|
return models.First();
|
|
}
|
|
private IEnumerable<AiModel> getAiModels()
|
|
{
|
|
var old_models = DAOFactory.GenericDAO.GetAll<AiModel>();
|
|
var new_models = ServiceFacade.OpenWebApiClient.GetAiModelle().GetResponseData();
|
|
var unknown_models = new_models.ToList();
|
|
|
|
foreach (var old_model in old_models)
|
|
{
|
|
bool found = false;
|
|
foreach (var new_model in new_models)
|
|
{
|
|
if (old_model.ModelName == new_model.ModelName)
|
|
{
|
|
if (old_model.IsActive != BS.Shared.ActivationTypeId.Active)
|
|
DAOFactory.GenericDAO.SetActivationType(old_model, BS.Shared.ActivationTypeId.Active);
|
|
|
|
found = true;
|
|
unknown_models.Remove(new_model);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
DAOFactory.GenericDAO.Deactivate(old_model);
|
|
}
|
|
|
|
if (unknown_models.Count != 0)
|
|
{
|
|
foreach (var unknown_model in unknown_models)
|
|
{
|
|
DAOFactory.GenericDAO.Insert(unknown_model);
|
|
}
|
|
}
|
|
|
|
var models = DAOFactory.GenericDAO.GetAllActive<AiModel>();
|
|
|
|
return models;
|
|
}
|
|
|
|
private AiConversation createAiConversation(int uicontext, Dictionary<TableID, long[]> context, long modell_oid, AiDataContextType context_Type)
|
|
{
|
|
var current_user = UserRightHelper.GetLoggedInUserWithOid();
|
|
var factory = getFactory(context_Type);
|
|
|
|
var system_prompt = factory.CreateSystemInstructions(uicontext, context);
|
|
|
|
var conv = new AiConversation();
|
|
conv.Created = DateTime.Now;
|
|
conv.ContextBeWoObjects = MapperFactory.AiConversation.Parse(context);
|
|
conv.Displayname = "Neue Unterhaltung";
|
|
conv.Messages = new List<AiConversationMessage>();
|
|
conv.Modell = DAOFactory.GenericDAO.LoadByID<AiModel>(modell_oid);
|
|
conv.UIContext = uicontext;
|
|
conv.ContextType = context_Type;
|
|
conv.Updated = DateTime.Now;
|
|
conv.ApplicationUserOid = current_user.Oid;
|
|
|
|
var msg = new AiConversationMessage();
|
|
msg.Message = system_prompt;
|
|
msg.AiConversation = conv;
|
|
msg.Role = AiConversationMessageRole.System;
|
|
msg.Created = DateTime.Now;
|
|
|
|
conv.Messages.Add(msg);
|
|
|
|
DAOFactory.GenericDAO.Insert(conv);
|
|
|
|
return conv;
|
|
}
|
|
|
|
private BaseAiPromptFactory getFactory(AiDataContextType context_Type)
|
|
{
|
|
if (context_Type == AiDataContextType.json)
|
|
return new JsonAiPromptFactory();
|
|
|
|
throw new NotImplementedException($"AiDataContextType {context_Type} not implemented.");
|
|
}
|
|
|
|
private AiConversationMessageDC[] sendNewMessage(AiConversation conv, string message, AiConfigDC config = null)
|
|
{
|
|
// Hole Config
|
|
if (config == null)
|
|
config = GetAiConfig();
|
|
var configModelName = config.SelectedModel.ModelName;
|
|
|
|
// Build Payload
|
|
var payload = new
|
|
{
|
|
model = configModelName,
|
|
messages = conv.Messages.Select(m => new { role = m.Role.ToString().ToLower(), content = m.Message })
|
|
};
|
|
|
|
// Check Token Size
|
|
if (!checkTokenSize(conv.Messages, configModelName))
|
|
{
|
|
throw new Exception();
|
|
}
|
|
|
|
// Updated
|
|
conv.Updated = DateTime.Now;
|
|
|
|
// Füge Message hinzu
|
|
var user_msg = new AiConversationMessage();
|
|
user_msg.Message = message;
|
|
user_msg.AiConversation = conv;
|
|
user_msg.Role = BS.Shared.AiConversationMessageRole.User;
|
|
user_msg.Created = DateTime.Now;
|
|
|
|
conv.Messages.Add(user_msg);
|
|
|
|
// Update DB Entity
|
|
// DAOFactory.GenericDAO.Update(conv);
|
|
|
|
var conv_dc = MapperFactory.AiConversation.MapToNewDC(conv);
|
|
var user_msg_dc = MapperFactory.AiConversationMessage.MapToNewDC(user_msg);
|
|
|
|
// Send Request, wait for Response
|
|
var dt_before_request = DateTime.Now;
|
|
var response = ServiceFacade.OpenWebApiClient.SendAiMessageRequest(payload, out var message2, out var model, out var duration);
|
|
|
|
if (!response.Success)
|
|
{
|
|
var json = JsonConvert.SerializeObject(response.Copy<string>());
|
|
File.WriteAllText(MergedConfig.GetSetting("AiServiceLogFilePath"), json);
|
|
}
|
|
|
|
var result = response.GetResponseData();
|
|
|
|
// Antwort
|
|
var assi_msg = new AiConversationMessage();
|
|
assi_msg.Message = message2;
|
|
assi_msg.AiConversation = conv;
|
|
assi_msg.Role = BS.Shared.AiConversationMessageRole.Assistent;
|
|
assi_msg.Created = dt_before_request;
|
|
assi_msg.Duration = duration ?? 0;
|
|
assi_msg.ModelName = model;
|
|
|
|
conv.Messages.Add(assi_msg);
|
|
|
|
// Update conv.
|
|
DAOFactory.GenericDAO.Update(conv);
|
|
|
|
var assi_msg_dc = MapperFactory.AiConversationMessage.MapToNewDC(assi_msg);
|
|
|
|
return new AiConversationMessageDC[] { user_msg_dc, assi_msg_dc };
|
|
}
|
|
|
|
private bool checkTokenSize(IList<AiConversationMessage> messages, string configModelName)
|
|
{
|
|
|
|
return true;
|
|
//Tokenizer tokenizer = TiktokenTokenizer.CreateForModel(configModelName);
|
|
|
|
//int tokens = countChatTokens(messages, tokenizer);
|
|
}
|
|
|
|
//private int countChatTokens(IList<AiConversationMessage> messages, Tokenizer tokenizer)
|
|
//{
|
|
// int tokensPerMessage = 4; // OpenAI Overhead
|
|
// int tokensPerReply = 2;
|
|
|
|
// int total = 0;
|
|
|
|
// foreach (var msg in messages)
|
|
// {
|
|
// total += tokensPerMessage;
|
|
// total += tokenizer.CountTokens(msg.Role.ToString());
|
|
// total += tokenizer.CountTokens(msg.Message);
|
|
// }
|
|
|
|
// return total + tokensPerReply;
|
|
//}
|
|
}
|
|
} |