update del icon

Feature 0.5.1

.gitignore

@@ -324,10 +324,6 @@ ASALocalRun/
 # MSBuild Binary and Structured Log
 *.binlog
 
-# NVidia Nsight GPU debugger configuration file
-*.nvuser
-*.dll
-*.pdb
 # MFractors (Xamarin productivity tool) working folder 
 .mfractor/
 **/bin/
@@ -337,7 +333,9 @@ ASALocalRun/
 /AntSK/appsettings.Development.json
 /AntSK.db
 **/tmp-memory-files/*
+**/tmp-memory-vectors/*
 /src/AntSK/AntSK.db
 /src/AntSK/appsettings.Development.json
 /src/AntSK.db
 /src/AntSK/llama_models
+/src/AntSK/AntSK.xml

Dockerfile

@@ -22,4 +22,5 @@ WORKDIR /app
 COPY --from=build /app/publish .
 RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
 RUN echo 'Asia/Shanghai' >/etc/timezone
+RUN apt update && apt install -y libpugixml-dev libtbb-dev
 ENTRYPOINT ["dotnet", "AntSK.dll"]

Dockerfile-py

@@ -0,0 +1,17 @@
+FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+WORKDIR /src
+COPY ["src/AntSK/AntSK.csproj", "AntSK/"]
+RUN dotnet restore "AntSK/AntSK.csproj"
+COPY src/ .
+WORKDIR "/src/AntSK"
+RUN dotnet build "AntSK.csproj" -c Release -o /app/build
+RUN dotnet publish "AntSK.csproj" -c Release -o /app/publish
+
+FROM registry.cn-hangzhou.aliyuncs.com/xuzeyu91/antsk-base:v1.0.0 AS final
+WORKDIR /app
+COPY --from=build /app/publish .
+
+ENV PATH="/app:/opt/conda/bin:/usr/local/bin:${PATH}"
+RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
+RUN echo 'Asia/Shanghai' >/etc/timezone
+ENTRYPOINT ["dotnet", "AntSK.dll"]

LICENSE

@@ -1,9 +1,17 @@
-                                 Apache License
+                                 AntSK License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
 
    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
+   This project follows the Apache 2.0 agreement, in addition to the following additional terms
+    1.This project can be used for commercial purposes, but it has the right to prohibit you from using it if it violates the following provisions
+    2. Without authorization, you are not allowed to modify AntSK's logo and title information
+    3. Without authorization, you are not allowed to modify the copyright information at the bottom of the page
+    4. If you need authorization, you can contact WeChat: xuzeyu91 or Email:antskpro@qq.com
+    
+
+   Apache 2.0 License
    1. Definitions.
 
       "License" shall mean the terms and conditions for use, reproduction,
@@ -186,7 +194,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright [2024] [许泽宇]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.en.md

@@ -1,215 +0,0 @@
-[简体中文](./README.md) | English
-# AntSK
-
-## Based on AI knowledge base/agent created by Net8+AntBlazor+SemanticKernel
-
-
-
-## Core functions
-
-
-
-- **Semantic Kernel**: It uses advanced natural language processing technology to accurately understand, process and respond to complex semantic queries, and provides users with accurate information retrieval and recommendation services.
-
-
-
-- **Kernel Memory**: It has the ability to continuously learn and store knowledge points. AntSK has a long-term memory function to accumulate experience and provide a more personalized interactive experience.
-
-
-
-- **Knowledge base**: Knowledge base documents can be created by importing knowledge base documents (Word, PDF, Excel, Txt, Markdown, Json, PPT) and other forms.
-
-
-
-- **API plug-in system**: an open API plug-in system that allows third-party developers or service providers to easily integrate their services into AntSK and continuously enhance application functions.
-
-
-
-- **Online search**: AntSK can obtain the latest information in real time to ensure that the information received by users is always the most timely and relevant.
-
-
-
-- **GPTs generation**: This platform supports the creation of personalized GPT models and attempts to build your own GPT models.
-
-
-
-- **API interface publishing**: internal functions are provided externally in the form of API, so that developers can easily translate Xzy AntSK KnowledgeBase is integrated into other applications to enhance application intelligence.
-
-- **Model management**: Adapt and manage different models from different vendors.
-
-
-
-## Application scenarios
-
-
-
-AntSK is applicable to a variety of business scenarios, such as:
-
-- Enterprise level knowledge management system
-
-- Automatic customer service and chat robot
-
-- Enterprise Search Engine
-
-- Personalized recommendation system
-
-- Intelligent assisted writing
-
-- Education and online learning platform
-
-- Other interesting AI Apps
-
-
-
-## Function example
-
-
-
-First, you need to create a knowledge base
-
-![Knowledge base](https://github.com/xuzeyu91/AntSK/blob/main/images/%E7%9F%A5%E8%AF%86%E5%BA%93.png)
-
-
-
-In the knowledge base, you can use documents or urls to import
-
-![Knowledge base details](https://github.com/xuzeyu91/AntSK/blob/main/images/%E7%9F%A5%E8%AF%86%E5%BA%93%E8%AF%A6%E6%83%85.png)
-
-
-
-Click View to view the document slicing of the knowledge base
-
-![Document Slice](https://github.com/xuzeyu91/AntSK/blob/main/images/%E6%96%87%E6%A1%A3%E5%88%87%E7%89%87.png)
-
-
-
-Then we need to create applications, which can create dialog applications and knowledge bases.
-
-![Application](https://github.com/xuzeyu91/AntSK/blob/main/images/%E5%BA%94%E7%94%A8.png)
-
-
-
-The application of knowledge base needs to select the existing knowledge base, which can be multiple
-
-![Application Configuration](https://github.com/xuzeyu91/AntSK/blob/main/images/%E5%BA%94%E7%94%A8%E9%85%8D%E7%BD%AE.png)
-
-
-
-Then you can ask questions about the knowledge base documents in the dialogue
-
-![Q&A](https://github.com/xuzeyu91/AntSK/blob/main/images/%E9%97%AE%E7%AD%94.png)
-
-
-
-In addition, we can also create dialogue applications, and configure prompt word templates in corresponding applications
-
-![Conversation application](https://github.com/xuzeyu91/AntSK/blob/main/images/%E7%AE%80%E5%8D%95%E5%AF%B9%E8%AF%9D.png)
-
-
-
-Let's see the effect
-
-![Conversation effect](https://github.com/xuzeyu91/AntSK/blob/main/images/%E5%AF%B9%E8%AF%9D%E6%95%88%E6%9E%9C.png)
-
-
-
-## How do I get started?
-
-Login is the default login account and password
-
-Here I use Postgres as data storage and vector storage, because both the Semantic Kernel and Kernel Memory support it. Of course, you can switch to other ones.
-
-The model supports openai by default. If you need to use azure openai and need to adjust the dependency injection of SK, you can also use one api for integration.
-
-The following configuration files need to be configured
-
-## Using Docker Compose
-Provided pg version appsettings. json and simplified version (Sqlite+disk) Docker Compose. simple. yml
-Download Docker Compose.yml from the project root directory, and then place the configuration file appsettings.json and it in a unified directory,
-The image of PG has been prepared here. You can modify the default account password in Docker Compose.yml, and your appsettings. json database connection needs to be consistent.
-Then you can enter the directory and execute it
-```
-docker compose up - d
-```
-To start AntSK
-
-Some meanings of configuration files
-
-```
-
-{
-  "DBConnection": {
-    "DbType": "Sqlite", 
-    "ConnectionStrings": "Data Source=AntSK.db;"
-  },
-  "OpenAIOption": {
-    "EndPoint": "http://localhost:5000/llama/",
-    "Key": "NotNull",
-    "Model": "gpt4-turbo",
-    "EmbeddingModel": "text-embedding-ada-002"
-  },
-  "KernelMemory": {
-    "VectorDb": "Disk", 
-    "ConnectionString": "Host=;Port=;Database=antsk;Username=;Password=",
-    "TableNamePrefix": "km-"
-  },
-  "LLamaSharp": {
-    "RunType": "GPU", 
-    "Chat": "D:\\Code\\AI\\AntBlazor\\model\\qwen1_5-1_8b-chat-q8_0.gguf",
-    "Embedding": "D:\\Code\\AI\\AntBlazor\\model\\qwen1_5-1_8b-chat-q8_0.gguf"
-  },
-  "Login": {
-    "User": "admin",
-    "Password": "xuzeyu"
-  },
-  "BackgroundTaskBroker": {
-    "ImportKMSTask": {
-      "WorkerCount": 1 
-    }
-  }
-}
-
-```
-
-```
-//Supports multiple databases, including SqlSugar, MySql, SqlServer, Sqlite, Oracle, PostgreSQL, Dm, Kdbndp, Oscar, MySqlConnector, Access, OpenGaussian, QuestDB, HG, ClickHouse, GBase, Odbc, OceanBaseForOracle, TDengine, GaussDB, OceanBase, Tidb, Vastbase, PolarDB, Custom
-DBConnection DbType
-//Connection string, corresponding strings need to be used according to different DB types
-DBConnection ConnectionStrings
-//You can use an online API that conforms to the OpenAI format (domestic models use one API adapter), or you can use AntSK's built-in llama API, with the IP and port being the AntSK startup address
-OpenAIOption EndPoint
-//Model key, if using a local model, it can default to Notnull. Chinese cannot be used here
-OpenAIOption Key
-//The type of vector storage supports Postgres Disk Memory, where Postgres requires the configuration of ConnectionString
-KernelMemory VectorDb
-//The running mode used by the local model is GUP CPU. If using an online API, you can freely use one
-LLamaSharp RunType
-//The model path of the local session model should pay attention to distinguishing between Linux and Windows drive letters
-LLamaSharp Chat
-//The model path of the local vector model should pay attention to distinguishing between Linux and Windows drive letters
-LLamaSharp Embedding
-//Default administrator account password
-Login
-//The number of threads for importing asynchronous processing can be higher when using online APIs. Local models suggest 1, otherwise memory overflow and crash may occur
-BackgroundTaskBroker ImportKMSTask WorkerCount
-
-```
-
-
-To learn more or start using**AntSK**, you can follow my public account and join the exchange group.
-
-
-
-## Contact me
-
-If you have any questions or suggestions, please follow my public account through the following ways, and send a message to me. We also have an exchange group, which can send messages such as joining the group, and then I will bring you into the exchange group
-
-![Official account](https://github.com/xuzeyu91/Avalonia-Assistant/blob/main/img/gzh.jpg)
-
-
-
----
-
-
-
-We appreciate your interest in**AntSK**and look forward to working with you to create an intelligent future!

README.md

@@ -1,98 +1,92 @@
-中文|[English](https://github.com/xuzeyu91/AntSK/blob/main/README.en.md)
+[简体中文](./README.zh.md) | English
 # AntSK
-## 基于.Net8+AntBlazor+SemanticKernel 打造的AI知识库/智能体
+## AI Knowledge Base/Intelligent Agent built on .Net8+AntBlazor+SemanticKernel
 
-## 核心功能
+## ⭐Core Features
 
-- **语义内核 (Semantic Kernel)**：采用领先的自然语言处理技术，准确理解、处理和响应复杂的语义查询，为用户提供精确的信息检索和推荐服务。
+- **Semantic Kernel**: Utilizes advanced natural language processing technology to accurately understand, process, and respond to complex semantic queries, providing users with precise information retrieval and recommendation services.
 
-- **内存内核 (Kernel Memory)**：具备持续学习和存储知识点的能力，AntSK 拥有长期记忆功能，累积经验，提供更个性化的交互体验。
+- **Kernel Memory**: Capable of continuous learning and storing knowledge points, AntSK has long-term memory function, accumulates experience, and provides a more personalized interaction experience.
 
-- **知识库**：通过文档（Word、PDF、Excel、Txt、Markdown、Json、PPT）等形式导入知识库，可以进行知识库文档。
+- **Knowledge Base**: Import knowledge base through documents (Word, PDF, Excel, Txt, Markdown, Json, PPT) and perform knowledge base Q&A.
 
-- **GPTs 生成**：此平台支持创建个性化的GPT模型，尝试构建您自己的GPT模型。
+- **GPT Generation**: This platform supports creating personalized GPT models, enabling users to build their own GPT models.
 
-- **API接口发布**：将内部功能以API的形式对外提供，便于开发者将AntSK 集成进其他应用，增强应用智慧。
+- **API Interface Publishing**: Exposes internal functions in the form of APIs, enabling developers to integrate AntSK into other applications and enhance application intelligence.
 
-- **API插件系统**：开放式API插件系统，允许第三方开发者或服务商轻松将其服务集成到AntSK，不断增强应用功能。
+- **API Plugin System**: Open API plugin system that allows third-party developers or service providers to easily integrate their services into AntSK, continuously enhancing application functionality.
 
-- **.Net插件系统（规划中）**：开放式dll插件系统，允许第三方开发者或服务商轻松将其业务功能通过标准格式的代码生成dll后集成到AntSK，不断增强应用功能。
+- **.Net Plugin System**: Open dll plugin system that allows third-party developers or service providers to easily integrate their business functions by generating dll in standard format code, continuously enhancing application functionality.
 
-- **联网搜索**：AntSK，实时获取最新信息，确保用户接受到的资料总是最及时、最相关的。
+- **Online Search**: AntSK, real-time access to the latest information, ensuring users receive the most timely and relevant data.
 
-- **模型管理**：适配和管理集成不同厂商的不同模型。并且支持llama.cpp所支持的gguf类型的模型离线运行
+- **Model Management**: Adapts and manages integration of different models from different manufacturers, including gguf types supported by **llama.cpp** and models offline running supported by **llamafactory** and **ollama**.
 
-## 应用场景
+- **Domestic Innovation**: AntSK supports domestic models and databases and can run under domestic innovation conditions.
 
-AntSK 适用于多种业务场景，例如：
-- 企业级知识管理系统
-- 自动客服与聊天机器人
-- 企业级搜索引擎
-- 个性化推荐系统
-- 智能辅助写作
-- 教育与在线学习平台
-- 其他有意思的AI App
+- **Model Fine-Tuning**: Planned based on llamafactory for model fine-tuning.
 
-## 功能示例
+## ⛪Application Scenarios
 
-[视频示例](https://www.bilibili.com/video/BV1zH4y1h7Y9/)
+AntSK is suitable for various business scenarios, such as:
+- Enterprise knowledge management system
+- Automatic customer service and chatbots
+- Enterprise search engine
+- Personalized recommendation system
+- Intelligent writing assistance
+- Education and online learning platforms
+- Other interesting AI Apps
 
-首先需要创建知识库
-![知识库](https://github.com/xuzeyu91/AntSK/blob/main/images/%E7%9F%A5%E8%AF%86%E5%BA%93.png)
+## ✏️Function Examples
+### Online Demo
+[document](http://antsk.cn/)
 
-在知识库里可以使用文档或者url进行导入
-![知识库详情](https://github.com/xuzeyu91/AntSK/blob/main/images/%E7%9F%A5%E8%AF%86%E5%BA%93%E8%AF%A6%E6%83%85.png)
+[demo](https://demo.antsk.cn/)
+and
+[demo1](https://antsk.ai-dotnet.com/)
 
-点击查看可以查看知识库的文档切片情况
-![文档切片](https://github.com/xuzeyu91/AntSK/blob/main/images/%E6%96%87%E6%A1%A3%E5%88%87%E7%89%87.png)
+```
+Default account: test
 
-然后我们需要创建应用，可以创建对话应用和知识库。
-![应用](https://github.com/xuzeyu91/AntSK/blob/main/images/%E5%BA%94%E7%94%A8.png)
+Default password: test
 
-知识库应用需要选择已有的知识库，可以选多个
-![应用配置](https://github.com/xuzeyu91/AntSK/blob/main/images/%E5%BA%94%E7%94%A8%E9%85%8D%E7%BD%AE.png)
+Due to the low configuration of the cloud server, the local model cannot be run, so the system settings permissions have been closed. You can simply view the interface. If you want to use the local model, please download and use it on your own.
+```
 
-然后再对话中可以对知识库的文档进行提问
-![问答](https://github.com/xuzeyu91/AntSK/blob/main/images/%E9%97%AE%E7%AD%94.png)
+### Other Function Examples
+[Video Demonstration](https://www.bilibili.com/video/BV1zH4y1h7Y9/)
 
-另外我们也可以创建对话应用，可以在对应应用中配置提示词模板
-![对话应用](https://github.com/xuzeyu91/AntSK/blob/main/images/%E7%AE%80%E5%8D%95%E5%AF%B9%E8%AF%9D.png)
+## ❓How to get started?
 
-下面来看看效果吧
-![对话效果](https://github.com/xuzeyu91/AntSK/blob/main/images/%E5%AF%B9%E8%AF%9D%E6%95%88%E6%9E%9C.png)
+Here I am using Postgres as the data and vector storage because Semantic Kernel and Kernel Memory support it, but you can also use other options.
 
-## 如何开始？
+The model by default supports the local model of openai, azure openai, and llama. If you need to use other models, you can integrate them using one-api.
 
-在这里我使用的是Postgres 作为数据存储和向量存储，因为Semantic Kernel和Kernel Memory都支持他，当然你也可以换成其他的。
+The Login configuration in the configuration file is the default login account and password.
 
-模型默认支持openai、azure openai 和llama支持的gguf本地模型,如果需要使用其他模型，可以使用one-api进行集成。
+The following configuration file needs to be configured
 
-配置文件中的Login配置是默认的登陆账号和密码
+## 1️⃣Using docker-compose
 
-需要配置如下的配置文件
+Provided the pg version **appsettings.json** and simplified version (Sqlite+disk) **docker-compose.simple.yml**
 
-## 使用docker-compose 
+Download **docker-compose.yml** from the project root directory and place the configuration file **appsettings.json** in the same directory.
 
-提供了pg版本 **appsettings.json** 和 简化版本（Sqlite+disk） **docker-compose.simple.yml**
+The pg image has already been prepared. You can modify the default username and password in docker-compose.yml, and then the database connection in your **appsettings.json** needs to be consistent.
 
-从项目根目录下载**docker-compose.yml**,然后把配置文件**appsettings.json**和它放在统一目录，
-
-这里已经把pg的镜像做好了。在docker-compose.yml中可以修改默认账号密码，然后你的**appsettings.json**的数据库连接需要保持一致。
-
-然后你可以进入到目录后执行
+Then you can execute the following command in the directory to start AntSK
 ```
 docker-compose up -d
 ```
-来启动AntSK
 
-## 如何在docker中挂载本地模型
+## 2️⃣How to mount local models and model download directory in docker
 ```
-# 非 host 版本, 不使用本机代理
+# Non-host version, do not use local proxy
 version: '3.8'
 services:
   antsk:
     container_name: antsk
-    image: registry.cn-hangzhou.aliyuncs.com/xuzeyu91/antsk:v0.1.5
+    image: registry.cn-hangzhou.aliyuncs.com/AIDotNet/antsk:v0.5.0
     ports:
       - 5000:5000
     networks:
@@ -103,32 +97,36 @@ services:
     environment:
       - ASPNETCORE_URLS=http://*:5000
     volumes:
-      - ./appsettings.json:/app/appsettings.json # 本地配置文件 需要放在同级目录
+      - ./appsettings.json:/app/appsettings.json # Local configuration file needs to be placed in the same directory
       - D://model:/app/model
 networks:
   antsk:
 ```
-以这个为示例，意思是把windows本地D://model的文件夹挂载进 容器内/app/model 如果是这样你的appsettings.json中的模型地址应该配置为  
-```
-model/xxx.gguf
-```
+Taking this as an example, it means mounting the local D://model folder of Windows into the container /app/model. If so, the model address in your appsettings.json should be configured as
 
-## 配置文件的一些含义
+[LiteDockerCompose](https://github.com/AIDotNet/AntSK/blob/main/docker-compose.simple.yml)
+
+The compact version is deployed with sqlite-disk by one click
+
+[FullDockerCompose](https://github.com/AIDotNet/AntSK/blob/main/docker-compose.yml)
+
+The full version uses pg+aspire
+
+
+## 3️⃣Some meanings of configuration file
 ```
 {
   "DBConnection": {
-    "DbType": "Sqlite", 
+    "DbType": "Sqlite",
     "ConnectionStrings": "Data Source=AntSK.db;"
   },
   "KernelMemory": {
-    "VectorDb": "Disk", 
+    "VectorDb": "Disk",
     "ConnectionString": "Host=;Port=;Database=antsk;Username=;Password=",
     "TableNamePrefix": "km-"
   },
-  "LLamaSharp": {
-    "RunType": "GPU", 
-    "Chat": "D:\\Code\\AI\\AntBlazor\\model\\qwen1_5-1_8b-chat-q8_0.gguf",
-    "Embedding": "D:\\Code\\AI\\AntBlazor\\model\\qwen1_5-1_8b-chat-q8_0.gguf"
+  "FileDir": {
+    "DirectoryPath": "D:\\git\\AntBlazor\\model"
   },
   "Login": {
     "User": "admin",
@@ -142,51 +140,95 @@ model/xxx.gguf
 }
 ```
 ```
-//支持多种数据库，具体可以查看SqlSugar，MySql，SqlServer，Sqlite，Oracle，PostgreSQL，Dm，Kdbndp，Oscar，MySqlConnector，Access，OpenGauss，QuestDB，HG，ClickHouse，GBase，Odbc，OceanBaseForOracle，TDengine，GaussDB，OceanBase，Tidb，Vastbase，PolarDB，Custom
+// Supports various databases, you can check SqlSugar, MySql, SqlServer, Sqlite, Oracle, PostgreSQL, Dm, Kdbndp, Oscar, MySqlConnector, Access, OpenGauss, QuestDB, HG, ClickHouse, GBase, Odbc, OceanBaseForOracle, TDengine, GaussDB, OceanBase, Tidb, Vastbase, PolarDB, Custom
 DBConnection.DbType
-//连接字符串，需要根据不同DB类型，用对应的字符串
+
+// Connection string, need to use the corresponding string according to the different DB types
 DBConnection.ConnectionStrings
 
-//向量存储的类型，支持  Postgres  Disk  Memory ，其中Postgres需要配置 ConnectionString
+//The type of vector storage, supporting Postgres, Disk, Memory, Qdrant, Redis, AzureAISearch
+//Postgres and Redis require ConnectionString configuration
+//The ConnectionString of Qdrant and AzureAISearch uses Endpoint | APIKey
 KernelMemory.VectorDb
 
-//本地模型使用的运行方式  GUP  CPU ,如果用在线API 这个随意使用一个即可
-LLamaSharp.RunType
-//本地会话模型的模型路径 注意区分linux和windows盘符不同
-LLamaSharp.Chat
-//本地向量模型的模型路径 注意区分linux和windows盘符不同
-LLamaSharp.Embedding
-//默认管理员账号密码
+//Local model path, used for quick selection of models under llama, as well as saving downloaded models.
+FileDir.DirectoryPath
 
+//Default admin account password
 Login
-//导入异步处理的线程数，使用在线API可以高一点，本地模型建议1 否则容易内存溢出崩掉
+
+//Import asynchronous processing thread count. A higher count can be used for online API, but for local models, 1 is recommended to avoid memory overflow issues.
 BackgroundTaskBroker.ImportKMSTask.WorkerCount
+
 ```
 
-## 找不到样式问题解决：
-AntSK/src/AntSK下执行:
+## ⚠️Fixing Style Issues:
+Run the following in AntSK/src/AntSK:
 ```
 dotnet clean
 dotnet build
 dotnet publish "AntSK.csproj"
 ```
-再去AntSK/src/AntSK/bin/Release/net8.0/publish下
+Then navigate to AntSK/src/AntSK/bin/Release/net8.0/publish and run:
 ```
 dotnet AntSK.dll
 ```
-然后启动就有样式了
+The styles should now be applied after starting.
 
-DB我使用的是CodeFirst模式，只要配置好数据库链接，表结构是自动创建的
+I'm using CodeFirst mode for the database, so as long as the database connection is properly configured, the table structure will be created automatically.
 
+## ✔️Using llamafactory
+```
+1. First, ensure that Python and pip are installed in your environment. This step is not necessary if using an image, such as version v0.2.3.2, which already includes the complete Python environment.
+2. Go to the model add page and select llamafactory.
+3. Click "Initialize" to check whether the 'pip install' environment setup is complete.
+4. Choose a model that you like.
+5. Click "Start" to begin downloading the model from the tower. This may involve a somewhat lengthy wait.
+6. After the model has finished downloading, enter http://localhost:8000/ in the request address. The default port is 8000.
+7. Click "Save" and start chatting.
+8. Many people ask about the difference between LLamaSharp and llamafactory. In fact, LLamaSharp is a .NET implementation of llama.cpp, but only supports local gguf models, while llamafactory supports a wider variety of models and uses Python implementation. The main difference lies here. Additionally, llamafactory has the ability to fine-tune models, which is an area we will focus on integrating in the future.
+```
 
+## 💕 Contributors
 
-想了解更多信息或开始使用 **AntSK**，可以关注我的公众号以及加入交流群。
+This project exists thanks to all the people who contribute.
 
-## 联系我
-如有任何问题或建议，请通过以下方式关注我的公众号，发消息与我联系，我们也有交流群，可以发送进群等消息，然后我会拉你进交流群
-![公众号](https://github.com/xuzeyu91/Avalonia-Assistant/blob/main/img/gzh.jpg)
+<a href="https://github.com/AIDotNet/AntSK/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=AIDotNet/AntSK&max=1000&columns=15&anon=1" />
+</a>
+
+## 🚨  Use Protocol
+
+This warehouse follows the [AntSK License](https://github.com/AIDotNet/AntSK?tab=Apache-2.0-1-ov-file) open source protocol.
+
+This project follows the Apache 2.0 agreement, in addition to the following additional terms
+
+1. This project can be used for commercial purposes, but it has the right to prohibit you from using it if it violates the following provisions
+
+2. Without authorization, you are not allowed to modify AntSK's logo and title information
+   
+4. Without authorization, you are not allowed to modify the copyright information at the bottom of the page
+   
+6. If you need authorization, you can contact WeChat: **xuzeyu91**
+
+If you plan to use AntSK in commercial projects, you need to ensure that you follow the following steps:
+
+1. Copyright statement containing AntSK license. [AntSK License](https://github.com/AIDotNet/AntSK?tab=Apache-2.0-1-ov-file).
+   
+2. If you modify the software source code, you need to clearly indicate these modifications in the source code.
+   
+3. Meet the above requirements  
+
+## 💕 Special thanks
+Helping enterprise AI application development, we recommend [AntBlazor](https://antblazor.com)
+
+## ☎️Contact Me
+If you have any questions or suggestions, please contact me through my official WeChat account. We also have a discussion group where you can send a message to join, and then I will add you to the group.
+
+Additionally, you can also contact me via email: antskpro@qq.com
+
+![Official WeChat Account](https://github.com/AIDotNet/AntSK/blob/main/images/gzh.jpg)
 
 ---
 
-我们对您在**AntSK**的兴趣表示感谢，并期待与您携手共创智能化的未来！
-
+We appreciate your interest in **AntSK** and look forward to collaborating with you to create an intelligent future!

README.zh.md

@@ -0,0 +1,247 @@
+中文|[English](./README.md) 
+# AntSK
+## 使用.Net8+Blazor+SemanticKernel 打造的AI知识库/智能体
+
+## ⭐核心功能
+
+- **语义内核 (Semantic Kernel)**：采用领先的自然语言处理技术，准确理解、处理和响应复杂的语义查询，为用户提供精确的信息检索和推荐服务。
+
+- **内存内核 (Kernel Memory)**：具备持续学习和存储知识点的能力，AntSK 拥有长期记忆功能，累积经验，提供更个性化的交互体验。
+
+- **知识库**：通过文档（Word、PDF、Excel、Txt、Markdown、Json、PPT）等形式导入知识库，可以进行知识库问答，支持本地bge-embedding 向量模型 ，以及bge-rerank 重排模型。
+
+- **文生图**：集成**StableDiffusion** 本地模型，可以进行文生图。
+
+- **GPTs 生成**：此平台支持创建个性化的GPT模型，尝试构建您自己的GPT模型。
+
+- **API接口发布**：将内部功能以API的形式对外提供，便于开发者将AntSK 集成进其他应用，增强应用智慧。
+
+- **API插件系统**：开放式API插件系统，允许第三方开发者或服务商轻松将其服务集成到AntSK，不断增强应用功能。
+
+- **.Net插件系统**：开放式dll插件系统，允许第三方开发者或服务商轻松将其业务功能通过标准格式的代码生成dll后集成到AntSK，不断增强应用功能。
+
+- **联网搜索**：AntSK，实时获取最新信息，确保用户接受到的资料总是最及时、最相关的。
+
+- **模型管理**：适配和管理集成不同厂商的不同模型。并且支持**llama.cpp**所支持的gguf类型，以及**llamafactory** 和 **ollama** 所支持的模型离线运行
+
+- **国产信创**：AntSK支持国产模型，和国产数据库，可以在信创条件下运行
+
+- **模型微调**：规划中，基于llamafactory进行模型微调
+  
+
+## ⛪应用场景
+
+AntSK 适用于多种业务场景，例如：
+- 企业级知识管理系统
+- 自动客服与聊天机器人
+- 企业级搜索引擎
+- 个性化推荐系统
+- 智能辅助写作
+- 教育与在线学习平台
+- 其他有意思的AI App
+
+## ✏️功能示例
+### 在线演示
+
+[体验地址1](https://demo.antsk.cn/)
+
+和
+
+[体验地址2](https://antsk.ai-dotnet.com/)
+```
+默认账号：test
+
+默认密码：test
+
+由于云服务器配置较低，无法运行本地模型，所以把系统设置权限关闭了，大家看看界面即可，要使用本地模型，请下载自行使用
+
+请勿在演示站点上传敏感信息
+```
+
+### 其他功能示例
+[视频示例](https://www.bilibili.com/video/BV1zH4y1h7Y9/)
+
+[在线文档：http://antsk.cn](http://antsk.cn)
+
+## ❓如何开始？
+
+在这里我使用的是Postgres 作为数据存储和向量存储，因为Semantic Kernel和Kernel Memory都支持他，当然你也可以换成其他的。
+
+模型默认支持openai、azure openai、讯飞星火、阿里云积、 和llama支持的gguf本地模型 以及llamafactory的本地模型,如果需要使用其他模型，可以使用one-api进行集成。
+
+配置文件中的Login配置是默认的登录账号和密码
+
+需要配置如下的配置文件
+
+## 1️⃣使用docker-compose 
+
+提供了pg版本 **appsettings.json** 和 简化版本（**Sqlite+disk**） **docker-compose.simple.yml**
+
+从项目根目录下载**docker-compose.yml**,然后把配置文件**appsettings.json**和它放在统一目录，
+
+这里已经把pg的镜像做好了。在docker-compose.yml中可以修改默认账号密码，然后你的**appsettings.json**的数据库连接需要保持一致。
+
+然后你可以进入到目录后执行
+```
+docker-compose up -d
+```
+来启动AntSK
+
+## 2️⃣如何在docker中挂载本地模型，和模型下载的目录
+```
+# 非 host 版本, 不使用本机代理
+version: '3.8'
+services:
+  antsk:
+    container_name: antsk
+    image: registry.cn-hangzhou.aliyuncs.com/AIDotNet/antsk:v0.3.1
+    ports:
+      - 5000:5000
+    networks:
+      - antsk
+    depends_on:
+      - antskpg
+    restart: always
+    environment:
+      - ASPNETCORE_URLS=http://*:5000
+    volumes:
+      - ./appsettings.json:/app/appsettings.json # 本地配置文件 需要放在同级目录
+      - D://model:/app/model
+      - D://model:/root/.cache/modelscope/hub/AI-ModelScope #使用Llamafactory时需要挂载 否则初始化的环境重启后会丢失
+networks:
+  antsk:
+```
+以这个为示例，意思是把windows本地D://model的文件夹挂载进 容器内/app/model 如果是这样你的appsettings.json中的模型地址应该配置为  
+
+[LiteDockerCompose](https://github.com/AIDotNet/AntSK/blob/main/docker-compose.simple.yml)
+
+精简版使用sqlite+disk向量模式，简化部署配置
+
+[FullDockerCompose](https://github.com/AIDotNet/AntSK/blob/main/docker-compose.yml)
+
+完整版使用pg+aspire 功能更完整，配置文件需要参考如下配置含义进行配置
+
+
+## 3️⃣配置文件的一些含义
+```
+{
+  "DBConnection": {
+    "DbType": "Sqlite", 
+    "ConnectionStrings": "Data Source=AntSK.db;"
+  },
+  "KernelMemory": {
+    "VectorDb": "Disk", 
+    "ConnectionString": "Host=;Port=;Database=antsk;Username=;Password=",
+    "TableNamePrefix": "km-"
+  },
+  "FileDir": {
+    "DirectoryPath": "D:\\git\\AntBlazor\\model"
+  },
+  "Login": {
+    "User": "admin",
+    "Password": "xuzeyu"
+  },
+  "BackgroundTaskBroker": {
+    "ImportKMSTask": {
+      "WorkerCount": 1 
+    }
+  }
+}
+```
+```
+//支持多种数据库，具体可以查看SqlSugar，MySql，SqlServer，Sqlite，Oracle，PostgreSQL，Dm，Kdbndp，Oscar，MySqlConnector，Access，OpenGauss，QuestDB，HG，ClickHouse，GBase，Odbc，OceanBaseForOracle，TDengine，GaussDB，OceanBase，Tidb，Vastbase，PolarDB，Custom
+DBConnection.DbType
+//连接字符串，需要根据不同DB类型，用对应的字符串
+DBConnection.ConnectionStrings
+
+//向量存储的类型，支持  Postgres、Disk、Memory、Qdrant、Redis、AzureAISearch
+//Postgres、Redis需要配置 ConnectionString
+//Qdrant 和AzureAISearch 的 ConnectionString 使用 Endpoint|APIKey  
+KernelMemory.VectorDb
+
+//本地模型路径，用于在选择llama时可以快速选择目录下的模型，以及保存下载的模型
+FileDir.DirectoryPath
+
+//默认管理员账号密码
+Login
+//导入异步处理的线程数，使用在线API可以高一点，本地模型建议1 否则容易内存溢出崩掉
+BackgroundTaskBroker.ImportKMSTask.WorkerCount
+```
+
+## ⚠️找不到样式问题解决：
+AntSK/src/AntSK下执行:
+```
+dotnet clean
+dotnet build
+dotnet publish "AntSK.csproj"
+```
+再去AntSK/src/AntSK/bin/Release/net8.0/publish下
+```
+dotnet AntSK.dll
+```
+然后启动就有样式了
+
+DB我使用的是CodeFirst模式，只要配置好数据库链接，表结构是自动创建的
+
+## ✔️使用llamafactory
+```
+1、首先需要确保你的环境已经安装了python和pip，如果使用镜像，例如p0.2.4版本已经包含了 python全套环境则无需此步骤
+2、进入模型添加页面选择llamafactory
+3、点击初始化，可以检查pip install 环境是否完成
+4、选择一个喜欢的模型
+5、点击启动,这会开始从魔塔下载模型，你可能需要有一个较为漫长的等待
+6、等待模型下载完毕后，在请求地址输入 http://localhost:8000/   这里默认是使用8000端口
+7、点击保存，然后就可以开始聊天了
+8、很多人会问 LLamaSharp与llamafactory有什么区别？其实这两者LLamaSharp是llama.cpp的 dotnet实现，但是只支持本地gguf模型，  而llamafactory 支持的模型种类更多，但使用的是python的实现，其主要差异在这里，另外llamafactory具有模型微调的能力，这也是我们下一步需要重点集成的部分。
+```
+
+## 💕 贡献者
+
+这个项目的存在要感谢所有的贡献者。
+
+<a href="https://github.com/AIDotNet/AntSK/graphs/contributors">
+<img src="https://contrib.rocks/image?repo=AIDotNet/AntSK&max=1000&columns=15&anon=1" />
+</a>
+
+## 🚨 使用协议
+
+本仓库遵循  [AntSK License](https://github.com/AIDotNet/AntSK?tab=Apache-2.0-1-ov-file) 开源协议。
+
+除以下附加条款外，该项目遵循Apache 2.0协议
+
+1. 本项目可以用于商业目的，但如果违反以下规定，它有权禁止您使用
+   
+2. 未经授权，您不允许修改AntSK的徽标和标题信息
+   
+3. 未经授权，您不能修改页面底部的版权信息
+   
+4. 如果您需要授权，可以联系微信：xuzeyu91
+
+如果您打算在商业项目中使用AntSK，您需要确保遵守以下步骤：
+
+1. 包含AntSK许可证的版权声明。 [AntSK License](https://github.com/AIDotNet/AntSK?tab=Apache-2.0-1-ov-file) 。
+
+2. 如果您修改了软件源代码，您需要在源代码中明确标明这些修改。
+
+3. 满足以上要求
+
+## 💕 特别感谢
+助力企业级AI应用开发，推荐使用 [AntBlazor](https://antblazor.com)
+
+
+## ☎️联系我
+如有任何问题或建议，请通过以下方式关注我的公众号《许泽宇的技术分享》，发消息与我联系，我们也有AIDotnet交流群，可以发送进群等消息，然后我会拉你进交流群
+
+另外您也可以通过邮箱与我联系：antskpro@qq.com
+
+![公众号](https://github.com/AIDotNet/AntSK/blob/main/images/gzh.jpg)
+
+## 🌟 Star History
+<a href="https://github.com/AIDotNet/AntSK/stargazers" target="_blank" style="display: block" align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=AIDotNet/AntSK&type=Date&theme=dark" />
+    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=AIDotNet/AntSK&type=Date" />
+    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=AIDotNet/AntSK&type=Date" />
+  </picture>
+</a>
+

docker-compose.simple.yml

@@ -3,7 +3,9 @@ version: '3.8'
 services:
   antsk:
     container_name: antsk
-    image: registry.cn-hangzhou.aliyuncs.com/xuzeyu91/antsk:v0.1.8
+    image: registry.cn-hangzhou.aliyuncs.com/xuzeyu91/antsk:v0.5.2
+    # 如果需要pytorch环境需要使用下面这个镜像，镜像比较大
+    # image: registry.cn-hangzhou.aliyuncs.com/xuzeyu91/antsk:p0.5.2
     ports:
       - 5000:5000
     networks:
@@ -13,5 +15,7 @@ services:
       - ASPNETCORE_URLS=http://*:5000
     volumes:
       - ./appsettings.json:/app/appsettings.json # 本地配置文件 需要放在同级目录
+      - /AntSK/model:/app/model
+      - /AntSK/model:/root/.cache/modelscope/hub/AI-ModelScope # LLamaFactory模型文件
 networks:
   antsk:

docker-compose.yml

@@ -1,6 +1,20 @@
 # 非 host 版本, 不使用本机代理
 version: '3.8'
 services:
+  aspire-dashboard:
+    container_name: aspire-dashboard
+    image: mcr.microsoft.com/dotnet/aspire-dashboard:8.0
+    networks:
+      - antsk
+    environment:
+      - DOTNET_DASHBOARD_UNSECURED_ALLOW_ANONYMOUS=true
+      - ASPIRE_ALLOW_UNSECURED_TRANSPORT=true
+      - DASHBOARD_OTLP_AUTHMODE=ApiKey
+      - DASHBOARD_OTLP_PRIMARYAPIKEY=antsk
+    ports:
+      - 18888:18888
+      - 18889:18889
+    restart: unless-stopped
   antskpg:
     image: registry.cn-hangzhou.aliyuncs.com/xuzeyu91/pg:v0.5.0 
     container_name: antskpg
@@ -18,7 +32,9 @@ services:
       - ./pg/data:/var/lib/postgresql/data
   antsk:
     container_name: antsk
-    image: registry.cn-hangzhou.aliyuncs.com/xuzeyu91/antsk:v0.1.8
+    image: registry.cn-hangzhou.aliyuncs.com/xuzeyu91/antsk:v0.5.2
+    # 如果需要pytorch环境需要使用下面这个镜像，镜像比较大
+    # image: registry.cn-hangzhou.aliyuncs.com/xuzeyu91/antsk:p0.5.2
     ports:
       - 5000:5000
     networks:
@@ -28,7 +44,15 @@ services:
     restart: always
     environment:
       - ASPNETCORE_URLS=http://*:5000
+      - ASPNETCORE_FORWARDEDHEADERS_ENABLED=true
+      - OTEL_DOTNET_EXPERIMENTAL_OTLP_EMIT_EXCEPTION_LOG_ATTRIBUTES=true
+      - OTEL_DOTNET_EXPERIMENTAL_OTLP_EMIT_EVENT_LOG_ATTRIBUTES= true
+      - OTEL_DOTNET_EXPERIMENTAL_OTLP_RETRY=in_memory
+      - OTEL_EXPORTER_OTLP_ENDPOINT=http://aspire-dashboard:18889
+      - OTEL_SERVICE_NAME=antsk
     volumes:
       - ./appsettings.json:/app/appsettings.json # 本地配置文件 需要放在同级目录
+      - /AntSK/model:/app/model
+      - /AntSK/model:/root/.cache/modelscope/hub/AI-ModelScope # LLamaFactory模型文件
 networks:
   antsk:

docs/deploy/_category_.json

@@ -0,0 +1,14 @@
+{
+    "position": 3,
+    "label": "部署",
+    "collapsible": true,
+    "collapsed": false,
+    "className": "red",
+    "link": {
+        "type": "generated-index",
+        "title": "使用案例"
+    },
+    "customProps": {
+        "description": "提供快速使用AntSK的一些案例！"
+    }
+}

docs/deploy/settings.md

@@ -0,0 +1,56 @@
+---
+sidebar_position: 2
+---
+
+# 配置文件的一些含义
+```
+{
+  "DBConnection": {
+    "DbType": "Sqlite", 
+    "ConnectionStrings": "Data Source=AntSK.db;"
+  },
+  "KernelMemory": {
+    "VectorDb": "Disk", 
+    "ConnectionString": "Host=;Port=;Database=antsk;Username=;Password=",
+    "TableNamePrefix": "km-"
+  },
+  "LLamaSharp": {
+    "RunType": "GPU", 
+    "Chat": "D:\\Code\\AI\\AntBlazor\\model\\qwen1_5-1_8b-chat-q8_0.gguf",
+    "Embedding": "D:\\Code\\AI\\AntBlazor\\model\\qwen1_5-1_8b-chat-q8_0.gguf",
+    "FileDirectory": "D:\\Code\\AI\\AntBlazor\\model\\"
+  },
+  "Login": {
+    "User": "admin",
+    "Password": "xuzeyu"
+  },
+  "BackgroundTaskBroker": {
+    "ImportKMSTask": {
+      "WorkerCount": 1 
+    }
+  }
+}
+```
+```
+//支持多种数据库，具体可以查看SqlSugar，MySql，SqlServer，Sqlite，Oracle，PostgreSQL，Dm，Kdbndp，Oscar，MySqlConnector，Access，OpenGauss，QuestDB，HG，ClickHouse，GBase，Odbc，OceanBaseForOracle，TDengine，GaussDB，OceanBase，Tidb，Vastbase，PolarDB，Custom
+DBConnection.DbType
+//连接字符串，需要根据不同DB类型，用对应的字符串
+DBConnection.ConnectionStrings
+
+//向量存储的类型，支持  Postgres  Disk  Memory ，其中Postgres需要配置 ConnectionString
+KernelMemory.VectorDb
+
+//本地模型使用的运行方式  GUP  CPU ,如果用在线API 这个随意使用一个即可
+LLamaSharp.RunType
+//本地会话模型的模型路径 注意区分linux和windows盘符不同
+LLamaSharp.Chat
+//本地向量模型的模型路径 注意区分linux和windows盘符不同
+LLamaSharp.Embedding
+//本地模型路径，用于在选择llama时可以快速选择目录下的模型，以及保存下载的模型
+LLamaSharp.FileDirectory
+
+//默认管理员账号密码
+Login
+//导入异步处理的线程数，使用在线API可以高一点，本地模型建议1 否则容易内存溢出崩掉
+BackgroundTaskBroker.ImportKMSTask.WorkerCount
+```

docs/deploy/start.md

@@ -0,0 +1,57 @@
+---
+sidebar_position: 1
+---
+
+# 如何开始？
+
+在这里我使用的是Postgres 作为数据存储和向量存储，因为Semantic Kernel和Kernel Memory都支持他，当然你也可以换成其他的。
+
+模型默认支持openai、azure openai 和llama支持的gguf本地模型,如果需要使用其他模型，可以使用one-api进行集成。
+
+配置文件中的Login配置是默认的登陆账号和密码
+
+需要配置如下的配置文件
+
+## 使用docker-compose 
+
+提供了pg版本 **appsettings.json** 和 简化版本（Sqlite+disk） **docker-compose.simple.yml**
+
+从项目根目录下载**docker-compose.yml**,然后把配置文件**appsettings.json**和它放在统一目录，
+
+这里已经把pg的镜像做好了。在docker-compose.yml中可以修改默认账号密码，然后你的**appsettings.json**的数据库连接需要保持一致。
+
+然后你可以进入到目录后执行
+```
+docker-compose up -d
+```
+来启动AntSK
+
+## 如何在docker中挂载本地模型，和模型下载的目录
+```
+# 非 host 版本, 不使用本机代理
+version: '3.8'
+services:
+  antsk:
+    container_name: antsk
+    image: registry.cn-hangzhou.aliyuncs.com/AIDotNet/antsk:v0.1.5
+    ports:
+      - 5000:5000
+    networks:
+      - antsk
+    depends_on:
+      - antskpg
+    restart: always
+    environment:
+      - ASPNETCORE_URLS=http://*:5000
+    volumes:
+      - ./appsettings.json:/app/appsettings.json # 本地配置文件 需要放在同级目录
+      - D://model:/app/model
+networks:
+  antsk:
+```
+以这个为示例，意思是把windows本地D://model的文件夹挂载进 容器内/app/model 如果是这样你的appsettings.json中的模型地址应该配置为  
+```
+model/xxx.gguf
+```
+
+DB我使用的是CodeFirst模式，只要配置好数据库链接，表结构是自动创建的

docs/deploy/style.md

@@ -0,0 +1,16 @@
+---
+sidebar_position: 3
+---
+
+# 找不到样式问题解决
+AntSK/src/AntSK下执行:
+```
+dotnet clean
+dotnet build
+dotnet publish "AntSK.csproj"
+```
+再去AntSK/src/AntSK/bin/Release/net8.0/publish下
+```
+dotnet AntSK.dll
+```
+然后启动就有样式了

docs/develop/_category_.json

@@ -0,0 +1,14 @@
+{
+    "position": 2,
+    "label": "快速开发",
+    "collapsible": true,
+    "collapsed": false,
+    "className": "red",
+    "link": {
+        "type": "generated-index",
+        "title": "快速开发"
+    },
+    "customProps": {
+        "description": "快速基于项目二次开发！"
+    }
+}

docs/introduce/_category_.json

@@ -0,0 +1,14 @@
+{
+    "position": 2,
+    "label": "介绍",
+    "collapsible": true,
+    "collapsed": false,
+    "className": "red",
+    "link": {
+        "type": "generated-index",
+        "title": "使用案例"
+    },
+    "customProps": {
+        "description": "提供快速使用AntSK的一些案例！"
+    }
+}

docs/introduce/readme.md

@@ -0,0 +1,70 @@
+---
+sidebar_position: 1
+---
+
+# AntSK功能介绍
+## 基于.Net8+AntBlazor+SemanticKernel 打造的AI知识库/智能体
+
+## 核心功能
+
+- **语义内核 (Semantic Kernel)**：采用领先的自然语言处理技术，准确理解、处理和响应复杂的语义查询，为用户提供精确的信息检索和推荐服务。
+
+- **内存内核 (Kernel Memory)**：具备持续学习和存储知识点的能力，AntSK 拥有长期记忆功能，累积经验，提供更个性化的交互体验。
+
+- **知识库**：通过文档（Word、PDF、Excel、Txt、Markdown、Json、PPT）等形式导入知识库，可以进行知识库问答。
+
+- **GPTs 生成**：此平台支持创建个性化的GPT模型，尝试构建您自己的GPT模型。
+
+- **API接口发布**：将内部功能以API的形式对外提供，便于开发者将AntSK 集成进其他应用，增强应用智慧。
+
+- **API插件系统**：开放式API插件系统，允许第三方开发者或服务商轻松将其服务集成到AntSK，不断增强应用功能。
+
+- **.Net插件系统**：开放式dll插件系统，允许第三方开发者或服务商轻松将其业务功能通过标准格式的代码生成dll后集成到AntSK，不断增强应用功能。
+
+- **联网搜索**：AntSK，实时获取最新信息，确保用户接受到的资料总是最及时、最相关的。
+
+- **模型管理**：适配和管理集成不同厂商的不同模型。并且支持**llama.cpp**所支持的gguf类型，以及**llamafactory**所支持的模型离线运行
+
+- **国产信创**：AntSK支持国产模型，和国产数据库，可以在信创条件下运行
+
+- **模型微调**：规划中，基于llamafactory进行模型微调
+  
+
+## 应用场景
+
+AntSK 适用于多种业务场景，例如：
+- 企业级知识管理系统
+- 自动客服与聊天机器人
+- 企业级搜索引擎
+- 个性化推荐系统
+- 智能辅助写作
+- 教育与在线学习平台
+- 其他有意思的AI App
+
+## 功能示例
+
+[视频示例](https://www.bilibili.com/video/BV1zH4y1h7Y9/)
+
+首先需要创建知识库
+![知识库](./img/知识库.png)
+
+在知识库里可以使用文档或者url进行导入
+![知识库详情](./img/知识库详情.png)
+
+点击查看可以查看知识库的文档切片情况
+![文档切片](./img/文档切片.png)
+
+然后我们需要创建应用，可以创建对话应用和知识库。
+![应用](./img/应用.png)
+
+知识库应用需要选择已有的知识库，可以选多个
+![应用配置](./img/应用配置.png)
+
+然后再对话中可以对知识库的文档进行提问
+![问答](./img/问答.png)
+
+另外我们也可以创建对话应用，可以在对应应用中配置提示词模板
+![对话应用](./img/简单对话.png)
+
+下面来看看效果吧
+![对话效果](./img/对话效果.png)

src/AntSK.AppHost/AntSK.AppHost.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsAspireHost>true</IsAspireHost>
+    <UserSecretsId>32ac67c8-178a-4eeb-871d-879023582e06</UserSecretsId>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Aspire.Hosting.AppHost" Version="8.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\AntSK\AntSK.csproj" />
+  </ItemGroup>
+
+</Project>

src/AntSK.AppHost/Program.cs

@@ -0,0 +1,5 @@
+var builder = DistributedApplication.CreateBuilder(args);
+
+builder.AddProject<Projects.AntSK>("antsk");
+
+builder.Build().Run();

src/AntSK.AppHost/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

src/AntSK.AppHost/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning",
+      "Aspire.Hosting.Dcp": "Warning"
+    }
+  }
+}

src/AntSK.AppHost/aspirate-output/docker-compose.yaml

@@ -0,0 +1,26 @@
+services:
+  aspire-dashboard:
+    container_name: "aspire-dashboard"
+    image: "mcr.microsoft.com/dotnet/aspire-dashboard:8.0"
+    environment:
+      DOTNET_DASHBOARD_UNSECURED_ALLOW_ANONYMOUS: "true"
+    ports:
+    - target: 18888
+      published: 18888
+    restart: unless-stopped
+  antsk:
+    container_name: "antsk"
+    image: "antsk:latest"
+    environment:
+      OTEL_DOTNET_EXPERIMENTAL_OTLP_EMIT_EXCEPTION_LOG_ATTRIBUTES: "true"
+      OTEL_DOTNET_EXPERIMENTAL_OTLP_EMIT_EVENT_LOG_ATTRIBUTES: "true"
+      OTEL_DOTNET_EXPERIMENTAL_OTLP_RETRY: "in_memory"
+      ASPNETCORE_FORWARDEDHEADERS_ENABLED: "true"
+      OTEL_EXPORTER_OTLP_ENDPOINT: "http://aspire-dashboard:18889"
+      OTEL_SERVICE_NAME: "antsk"
+    ports:
+    - target: 8080
+      published: 10000
+    - target: 8443
+      published: 10001
+    restart: unless-stopped

src/AntSK.AppHost/aspirate-state.json

@@ -0,0 +1,17 @@
+{
+  "projectPath": ".",
+  "outputPath": "aspirate-output",
+  "containerImageTags": [
+    "latest"
+  ],
+  "containerBuilder": "docker",
+  "outputFormat": "compose",
+  "privateRegistryEmail": "aspir8@aka.ms",
+  "includeDashboard": true,
+  "secrets": {
+    "salt": "fjamZa3pQbM1UyY4",
+    "hash": "QR\u002BSEr3p2SwD/w2oPE21vrWh/EerhNyVyTkr0atIREw=",
+    "secrets": {}
+  },
+  "processAllComponents": true
+}

src/AntSK.AppHost/manifest.json

@@ -0,0 +1,26 @@
+{
+  "resources": {
+    "antsk": {
+      "type": "project.v0",
+      "path": "../AntSK/AntSK.csproj",
+      "env": {
+        "OTEL_DOTNET_EXPERIMENTAL_OTLP_EMIT_EXCEPTION_LOG_ATTRIBUTES": "true",
+        "OTEL_DOTNET_EXPERIMENTAL_OTLP_EMIT_EVENT_LOG_ATTRIBUTES": "true",
+        "OTEL_DOTNET_EXPERIMENTAL_OTLP_RETRY": "in_memory",
+        "ASPNETCORE_FORWARDEDHEADERS_ENABLED": "true"
+      },
+      "bindings": {
+        "http": {
+          "scheme": "http",
+          "protocol": "tcp",
+          "transport": "http"
+        },
+        "https": {
+          "scheme": "https",
+          "protocol": "tcp",
+          "transport": "http"
+        }
+      }
+    }
+  }
+}

src/AntSK.Domain/AntSK - Backup.Domain.csproj

@@ -0,0 +1,53 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <DocumentationFile>AntSK.Domain.xml</DocumentationFile>
+    <NoWarn>CA1050,CA1707,CA2007,VSTHRD111,CS1591,RCS1110,CA5394,SKEXP0001,SKEXP0002,SKEXP0003,SKEXP0004,SKEXP0010,SKEXP0011,,SKEXP0012,SKEXP0020,SKEXP0021,SKEXP0022,SKEXP0023,SKEXP0024,SKEXP0025,SKEXP0026,SKEXP0027,SKEXP0028,SKEXP0029,SKEXP0030,SKEXP0031,SKEXP0032,SKEXP0040,SKEXP0041,SKEXP0042,SKEXP0050,SKEXP0051,SKEXP0052,SKEXP0053,SKEXP0054,SKEXP0055,SKEXP0060,SKEXP0061,SKEXP0101,SKEXP0102</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="AntDesign.Charts" Version="0.5.1" />
+    <PackageReference Include="AntDesign.ProLayout" Version="0.18.2" />
+    <PackageReference Include="BlazorComponents.Terminal" Version="0.6.0" />
+    <PackageReference Include="Blazored.LocalStorage" Version="4.5.0" />
+  
+    <PackageReference Include="pythonnet" Version="3.0.3" />
+    
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
+    
+    <PackageReference Include="AutoMapper" Version="8.1.0" />
+    <PackageReference Include="BCrypt.Net-Next" Version="4.0.3" />
+    <PackageReference Include="Markdig" Version="0.37.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="SqlSugarCore" Version="5.1.4.151" />
+    <PackageReference Include="System.Data.SQLite.Core" Version="1.0.118" />
+    <PackageReference Include="RestSharp" Version="110.2.0" />
+    <PackageReference Include="NPOI" Version="2.7.0" />
+    
+    <PackageReference Include="Microsoft.SemanticKernel" Version="1.7.1" />
+    <PackageReference Include="Microsoft.SemanticKernel.Core" Version="1.7.1" />
+    <PackageReference Include="Microsoft.SemanticKernel.Plugins.Core" Version="1.7.1-alpha" />
+    <PackageReference Include="Microsoft.KernelMemory.Core" Version="0.36.240415.2" />
+    <PackageReference Include="Microsoft.KernelMemory.MemoryDb.Postgres" Version="0.36.240415.2" />
+    <PackageReference Include="Microsoft.KernelMemory.MemoryDb.Qdrant" Version="0.36.240415.2" />
+    <PackageReference Include="Microsoft.KernelMemory.MemoryDb.Redis" Version="0.36.240415.2" />
+    <PackageReference Include="Microsoft.KernelMemory.MemoryDb.AzureAISearch" Version="0.36.240415.2" />
+
+    <PackageReference Include="LLamaSharp" Version="0.11.2" />
+    <PackageReference Include="LLamaSharp.Backend.Cpu" Version="0.11.2" />
+    <PackageReference Include="LLamaSharp.Backend.Cuda12" Version="0.11.2" />
+    <PackageReference Include="LLamaSharp.kernel-memory" Version="0.11.2" />
+    <PackageReference Include="LLamaSharp.semantic-kernel" Version="0.11.2" />
+    
+    
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\AntSK.LLamaFactory\AntSK.LLamaFactory.csproj" />
+    <ProjectReference Include="..\AntSk.LLM\AntSK.LLM.csproj" />
+    <ProjectReference Include="..\AntSK.OCR\AntSK.OCR.csproj" />
+    <ProjectReference Include="..\MiddleWare\AntSK.BackgroundTask\AntSK.BackgroundTask.csproj" />
+  </ItemGroup>
+
+</Project>

src/AntSK.Domain/AntSK.Domain.csproj

@@ -5,36 +5,48 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <DocumentationFile>AntSK.Domain.xml</DocumentationFile>
-    <NoWarn>CA1050,CA1707,CA2007,VSTHRD111,CS1591,RCS1110,CA5394,SKEXP0001,SKEXP0002,SKEXP0003,SKEXP0004,SKEXP0010,SKEXP0011,,SKEXP0012,SKEXP0020,SKEXP0021,SKEXP0022,SKEXP0023,SKEXP0024,SKEXP0025,SKEXP0026,SKEXP0027,SKEXP0028,SKEXP0029,SKEXP0030,SKEXP0031,SKEXP0032,SKEXP0040,SKEXP0041,SKEXP0042,SKEXP0050,SKEXP0051,SKEXP0052,SKEXP0053,SKEXP0054,SKEXP0055,SKEXP0060,SKEXP0061,SKEXP0101,SKEXP0102</NoWarn>
+    <NoWarn>CA1050,CA1707,CA2007,VSTHRD111,CS1591,RCS1110,CA5394,SKEXP0001,SKEXP0002,SKEXP0003,SKEXP0004,SKEXP0010,SKEXP0011,,SKEXP0012,SKEXP0020,SKEXP0021,SKEXP0022,SKEXP0023,SKEXP0024,SKEXP0025,SKEXP0026,SKEXP0027,SKEXP0028,SKEXP0029,SKEXP0030,SKEXP0031,SKEXP0032,SKEXP0040,SKEXP0041,SKEXP0042,SKEXP0050,SKEXP0051,SKEXP0052,SKEXP0053,SKEXP0054,SKEXP0055,SKEXP0060,SKEXP0061,SKEXP0101,SKEXP0102,KMEXP00</NoWarn>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="AntDesign.Charts" Version="0.5.1" />
-    <PackageReference Include="AntDesign.ProLayout" Version="0.18.0" />
+    <PackageReference Include="AntDesign.Charts" Version="0.5.5" />
+    <PackageReference Include="AntDesign.ProLayout" Version="0.20.3" />
+    <PackageReference Include="BlazorComponents.Terminal" Version="0.6.0" />
+    <PackageReference Include="Blazored.LocalStorage" Version="4.5.0" />
+  
+    <PackageReference Include="pythonnet" Version="3.0.3" />
+   
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.7.0" />
     
     <PackageReference Include="AutoMapper" Version="8.1.0" />
     <PackageReference Include="BCrypt.Net-Next" Version="4.0.3" />
-    <PackageReference Include="Markdig" Version="0.35.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="SqlSugarCore" Version="5.1.4.145" />
+    <PackageReference Include="Markdig" Version="0.37.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="$(NewtonsoftVersion)" />
+    <PackageReference Include="SqlSugarCore" Version="5.1.4.166" />
     <PackageReference Include="System.Data.SQLite.Core" Version="1.0.118" />
-    <PackageReference Include="RestSharp" Version="110.2.0" />
-    
-    <PackageReference Include="Microsoft.SemanticKernel" Version="1.4.0" />
-    <PackageReference Include="Microsoft.SemanticKernel.Core" Version="1.4.0" />
-    <PackageReference Include="Microsoft.SemanticKernel.Plugins.Core" Version="1.4.0-alpha" />
-    <PackageReference Include="Microsoft.KernelMemory.Core" Version="0.32.240308.1" />
-    <PackageReference Include="Microsoft.KernelMemory.MemoryDb.Postgres" Version="0.32.240308.1" />
+    <PackageReference Include="RestSharp" Version="$(RestSharpVersion)" />
+    <PackageReference Include="NPOI" Version="2.7.1" />
 
-    <PackageReference Include="LLamaSharp" Version="0.10.0" />
-    <PackageReference Include="LLamaSharp.Backend.Cpu" Version="0.10.0" />
-    <PackageReference Include="LLamaSharp.Backend.Cuda12" Version="0.10.0" />
-    <PackageReference Include="LLamaSharp.kernel-memory" Version="0.10.0" />
-    <PackageReference Include="LLamaSharp.semantic-kernel" Version="0.10.0" />
-    
-    
+    <PackageReference Include="Microsoft.SemanticKernel" Version="$(SKVersion)" />
+    <PackageReference Include="Microsoft.SemanticKernel.Core" Version="$(SKVersion)" />
+    <PackageReference Include="Microsoft.SemanticKernel.Plugins.Core" Version="$(SKVersion)-alpha" />
+    <PackageReference Include="Microsoft.KernelMemory.Core" Version="$(KMVersion)" />
+    <PackageReference Include="Microsoft.KernelMemory.MemoryDb.Postgres" Version="$(KMVersion)" />
+    <PackageReference Include="Microsoft.KernelMemory.MemoryDb.Qdrant" Version="$(KMVersion)" />
+    <PackageReference Include="Microsoft.KernelMemory.MemoryDb.Redis" Version="$(KMVersion)" />
+    <PackageReference Include="Microsoft.KernelMemory.MemoryDb.AzureAISearch" Version="$(KMVersion)" />
+
+    <PackageReference Include="Serilog" Version="4.0.1" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
+    <PackageReference Include="Serilog.Sinks.File" Version="6.0.0" />
+    <PackageReference Include="Serilog.Extensions.Logging" Version="8.0.1-dev-10391" />
+    <PackageReference Include="Serilog.Settings.Configuration" Version="8.0.2" />
+    <PackageReference Include="Serilog.Sinks.Seq" Version="8.0.0" />
+    <PackageReference Include="Serilog.Sinks.OpenTelemetry" Version="4.0.0" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\AntSk.LLM\AntSK.LLM.csproj" />
+    <ProjectReference Include="..\AntSK.LLamaFactory\AntSK.LLamaFactory.csproj" />
+    <ProjectReference Include="..\AntSK.LLM\AntSK.LLM.csproj" />
+    <ProjectReference Include="..\AntSK.OCR\AntSK.OCR.csproj" />
     <ProjectReference Include="..\MiddleWare\AntSK.BackgroundTask\AntSK.BackgroundTask.csproj" />
   </ItemGroup>
 

src/AntSK.Domain/AntSK.Domain.xml

@@ -17,6 +17,27 @@
             <param name="assemblies">程序集集合</param>
             <returns></returns>
         </member>
+        <member name="M:AntSK.Domain.Common.DependencyInjection.InitExtensions.CodeFirst(Microsoft.AspNetCore.Builder.WebApplication)">
+            <summary>
+            使用codefirst创建数据库表
+            </summary>
+            <param name="services"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AntSK.Domain.Common.DependencyInjection.InitExtensions.LoadFun(Microsoft.AspNetCore.Builder.WebApplication)">
+            <summary>
+            加载数据库的插件
+            </summary>
+            <param name="services"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AntSK.Domain.Common.DependencyInjection.InitExtensions.AddAntSKSwagger(Microsoft.Extensions.DependencyInjection.IServiceCollection)">
+            <summary>
+            swagger 初始化
+            </summary>
+            <param name="serviceCollection"></param>
+            <returns></returns>
+        </member>
         <member name="F:AntSK.Domain.Common.DependencyInjection.ServiceLifetime.Scoped">
             <summary>
             作用域
@@ -48,12 +69,132 @@
             <param name="value"></param>
             <returns></returns>
         </member>
-        <member name="F:AntSK.Domain.Domain.Other.LLamaConfig.dicLLamaWeights">
+        <member name="M:AntSK.Domain.ExeclHelper.ExcelToDataTable(System.String,System.Boolean)">
             <summary>
-            避免模型重复加载，本地缓存
+            将excel导入到datatable
+            </summary>
+            <param name="filePath">excel路径</param>
+            <param name="isColumnName">第一行是否是列名</param>
+            <returns>返回datatable</returns>
+        </member>
+        <member name="M:AntSK.Domain.ExeclHelper.ExcelToDataTable(System.IO.Stream,System.Boolean)">
+            <summary>
+            将excel导入到datatable
+            </summary>
+            <param name="stream">流</param>
+            <param name="isColumnName">第一行是否是列名</param>
+            <returns></returns>
+        </member>
+        <member name="M:AntSK.Domain.ExeclHelper.ExcelToList``1(System.IO.Stream)">
+            <summary>
+            excel转list
+            </summary>
+            <typeparam name="TResult"></typeparam>
+            <param name="stream"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AntSK.Domain.ExeclHelper.ExcelToList``1(System.IO.Stream,System.String)">
+            <summary>
+            excel转list-根据sheetName得到List
+            </summary>
+            <typeparam name="TResult"></typeparam>
+            <param name="stream"></param>
+            <param name="sheetName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AntSK.Domain.ExeclHelper.ListToExcel``1(``0[],System.String)">
+            <summary>
+            List导出excel 二进制流
+            </summary>
+            <typeparam name="T">实体</typeparam>
+            <param name="data">List</param>
+            <param name="sheetName">sheetname 可不填，默认Sheet0</param>
+            <returns></returns>
+        </member>
+        <member name="M:AntSK.Domain.ExeclHelper.DataTableToExcel(System.Data.DataTable,System.String,System.String)">
+            <summary>
+             Dt导出excel 二进制流
+            </summary>
+            <param name="dt">datatable</param>
+            <param name="strFile">strFile</param>
+            <returns></returns>
+        </member>
+        <member name="M:AntSK.Domain.ExeclHelper.ListWriteExcel``1(``0[],System.String,System.String)">
+            <summary>
+            List写入excel
+            </summary>
+            <typeparam name="T"></typeparam>
+            <param name="data"></param>
+            <param name="strFile">路径</param>
+            <param name="sheetName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AntSK.Domain.ExeclHelper.DataTableWriteExcel(System.Data.DataTable,System.String,System.String)">
+            <summary>
+            dt写入excel
+            </summary>
+            <param name="dt">datatable</param>
+            <param name="strFile">路径</param>
+            <returns></returns>
+        </member>
+        <member name="M:AntSK.Domain.ExeclHelper.SetCellDropdownList(NPOI.SS.UserModel.IWorkbook,NPOI.SS.UserModel.ISheet,System.Collections.Generic.List{System.String},System.String,System.Int32,System.Int32,System.Int32)">
+            <summary>
+            设置单元格下拉框(除去标题行)
+            </summary>
+            <param name="workbook"></param>
+            <param name="sheet"></param>
+            <param name="ddlList"></param>
+            <param name="firstcol"></param>
+            <param name="lastcol"></param>
+        </member>
+        <member name="T:AntSK.Domain.Domain.Model.Enum.AIType">
+            <summary>
+            AI类型
             </summary>
         </member>
-        <member name="M:AntSK.Domain.Domain.Service.ChatService.SendChatByAppAsync(AntSK.Domain.Repositories.Apps,System.String,System.String)">
+        <member name="T:AntSK.Domain.Domain.Model.Enum.AIModelType">
+            <summary>
+            模型类型
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Domain.Model.PageList`1.PageIndex">
+            <summary>
+            当前页，从1开始
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Domain.Model.PageList`1.PageSize">
+            <summary>
+            每页数量
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Domain.Model.PageList`1.TotalCount">
+            <summary>
+            总数
+            </summary>
+        </member>
+        <member name="M:AntSK.Domain.Domain.Other.Bge.BegRerankConfig.LoadModel(System.String,System.String)">
+            <summary>
+            模型写死
+            </summary>
+        </member>
+        <member name="M:AntSK.Domain.Domain.Other.Bge.BgeEmbeddingConfig.LoadModel(System.String,System.String)">
+            <summary>
+            模型写死
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Domain.Other.KMExcelHandler.StepName">
+            <inheritdoc />
+        </member>
+        <member name="M:AntSK.Domain.Domain.Other.KMExcelHandler.InvokeAsync(Microsoft.KernelMemory.Pipeline.DataPipeline,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="P:AntSK.Domain.Domain.Other.QAHandler.StepName">
+            <inheritdoc />
+        </member>
+        <member name="M:AntSK.Domain.Domain.Other.QAHandler.InvokeAsync(Microsoft.KernelMemory.Pipeline.DataPipeline,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:AntSK.Domain.Domain.Service.ChatService.SendChatByAppAsync(AntSK.Domain.Repositories.Apps,Microsoft.SemanticKernel.ChatCompletion.ChatHistory)">
             <summary>
             发送消息
             </summary>
@@ -82,6 +223,20 @@
             <param name="app"></param>
             <param name="_kernel"></param>
         </member>
+        <member name="M:AntSK.Domain.Domain.Service.KernelService.ImportApiFunction(AntSK.Domain.Repositories.Apps,System.Collections.Generic.List{Microsoft.SemanticKernel.KernelFunction})">
+            <summary>
+            导入API插件
+            </summary>
+            <param name="app"></param>
+            <param name="functions"></param>
+        </member>
+        <member name="M:AntSK.Domain.Domain.Service.KernelService.ImportNativeFunction(AntSK.Domain.Repositories.Apps,System.Collections.Generic.List{Microsoft.SemanticKernel.KernelFunction})">
+            <summary>
+            导入原生插件
+            </summary>
+            <param name="app"></param>
+            <param name="functions"></param>
+        </member>
         <member name="M:AntSK.Domain.Domain.Service.KernelService.RegisterPluginsWithKernel(Microsoft.SemanticKernel.Kernel)">
             <summary>
             注册默认插件
@@ -97,61 +252,6 @@
             <param name="history"></param>
             <returns></returns>
         </member>
-        <member name="M:AntSK.Domain.Map.MapperExtend.ToDTOList``1(System.Object)">
-            <summary>
-            Entity集合转DTO集合
-            </summary>
-            <typeparam name="T"></typeparam>
-            <param name="value"></param>
-            <returns></returns>
-        </member>
-        <member name="M:AntSK.Domain.Map.MapperExtend.ToDTO``1(System.Object)">
-            <summary>
-            Entity转DTO
-            </summary>
-            <typeparam name="T"></typeparam>
-            <param name="value"></param>
-            <returns></returns>
-        </member>
-        <member name="M:AntSK.Domain.Map.MapperExtend.MapTo``1(System.Object,``0)">
-            <summary>
-            给已有对象map,适合update场景，如需过滤空值需要在AutoMapProfile 设置
-            </summary>
-            <typeparam name="T"></typeparam>
-            <param name="self"></param>
-            <param name="result"></param>
-            <returns></returns>
-        </member>
-        <member name="T:AntSK.Domain.Model.Enum.AIType">
-            <summary>
-            AI类型
-            </summary>
-        </member>
-        <member name="T:AntSK.Domain.Model.Enum.AIModelType">
-            <summary>
-            模型类型
-            </summary>
-        </member>
-        <member name="P:AntSK.Domain.Model.MessageInfo.IsSend">
-            <summary>
-            发送是true  接收是false
-            </summary>
-        </member>
-        <member name="P:AntSK.Domain.Model.PageList`1.PageIndex">
-            <summary>
-            当前页，从1开始
-            </summary>
-        </member>
-        <member name="P:AntSK.Domain.Model.PageList`1.PageSize">
-            <summary>
-            每页数量
-            </summary>
-        </member>
-        <member name="P:AntSK.Domain.Model.PageList`1.TotalCount">
-            <summary>
-            总数
-            </summary>
-        </member>
         <member name="P:AntSK.Domain.Options.DBConnectionOption.DbType">
             <summary>
             sqlite连接字符串
@@ -242,6 +342,11 @@
             会话模型ID
             </summary>
         </member>
+        <member name="P:AntSK.Domain.Repositories.Apps.EmbeddingModelID">
+            <summary>
+            Embedding 模型Id
+            </summary>
+        </member>
         <member name="P:AntSK.Domain.Repositories.Apps.Temperature">
             <summary>
             温度
@@ -272,6 +377,61 @@
             API调用秘钥
             </summary>
         </member>
+        <member name="P:AntSK.Domain.Repositories.Apps.Relevance">
+            <summary>
+            相似度
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Repositories.Apps.MaxAskPromptSize">
+            <summary>
+            提问最大token数
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Repositories.Apps.MaxMatchesCount">
+            <summary>
+            向量匹配数
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Repositories.Apps.AnswerTokens">
+            <summary>
+            回答最大token数
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Repositories.Chats.UserName">
+            <summary>
+            用户名
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Repositories.Chats.AppId">
+            <summary>
+            应用ID
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Repositories.Chats.Context">
+            <summary>
+            消息内容
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Repositories.Chats.IsSend">
+            <summary>
+            发送是true  接收是false
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Repositories.Chats.CreateTime">
+            <summary>
+            创建事件
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Repositories.Chats.FileName">
+            <summary>
+            文件名
+            </summary>
+        </member>
+        <member name="P:AntSK.Domain.Repositories.Funs.Path">
+            <summary>
+            接口描述
+            </summary>
+        </member>
         <member name="P:AntSK.Domain.Repositories.KmsDetails.FileName">
             <summary>
             文件名称
@@ -744,6 +904,35 @@
             <param name="stream"></param>
             <returns></returns>
         </member>
+        <member name="M:AntSK.Domain.Utils.ConvertUtils.ToQueryString(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            json参数转化querystring参数
+            </summary>
+            <param name="parameters"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AntSK.Domain.Utils.ConvertUtils.ComparisonIgnoreCase(System.String,System.String)">
+            <summary>
+            忽略大小写匹配
+            </summary>
+            <param name="s"></param>
+            <param name="value"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AntSK.Domain.Utils.ConvertUtils.Unescape(System.String)">
+            <summary>
+            \uxxxx转中文,保留换行符号
+            </summary>
+            <param name="unicodeString"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AntSK.Domain.Utils.ConvertUtils.IsStream(System.String)">
+            <summary>
+            是否为流式请求
+            </summary>
+            <param name="value"></param>
+            <returns></returns>
+        </member>
         <member name="M:AntSK.Domain.Utils.RepoFiles.SamplePluginsPath">
             <summary>
             Scan the local folders from the repo, looking for "samples/plugins" folder.

src/AntSK.Domain/Common/AntSkFunctionAttribute.cs

@@ -1,7 +1,7 @@
 namespace AntSK.Domain.Common
 {
     [AttributeUsage(AttributeTargets.Method)]
-    public class AntSkFunctionAttribute : Attribute
+    public class AntSKFunctionAttribute : Attribute
     {
         // 自定义的ActionAttribute
     }

src/AntSK.Domain/Common/DependencyInjection/InitExtensions.cs

@@ -0,0 +1,175 @@
+using AntSK.Domain.Domain.Model.Constant;
+using AntSK.Domain.Domain.Service;
+using AntSK.Domain.Repositories;
+using DocumentFormat.OpenXml.Office2016.Drawing.ChartDrawing;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.OpenApi.Models;
+using SqlSugar;
+using Swashbuckle.AspNetCore.SwaggerGen;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AntSK.Domain.Common.DependencyInjection
+{
+    public static class InitExtensions
+    {
+        private static ILogger _logger;
+
+        public static void InitLog(ILogger logger)
+        {
+            _logger = logger;
+        }
+        /// <summary>
+        /// 使用codefirst创建数据库表
+        /// </summary>
+        /// <param name="services"></param>
+        /// <returns></returns>
+        public static WebApplication CodeFirst(this WebApplication app)
+        {
+            using (var scope = app.Services.CreateScope())
+            {
+                // 获取仓储服务
+                var _repository = scope.ServiceProvider.GetRequiredService<IApps_Repositories>();
+
+                // 创建数据库（如果不存在）
+                _repository.GetDB().DbMaintenance.CreateDatabase();
+
+                // 获取当前应用程序域中所有程序集
+                var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+
+                // 在所有程序集中查找具有[SugarTable]特性的类
+                foreach (var assembly in assemblies)
+                {
+                    // 获取该程序集中所有具有SugarTable特性的类型
+                    var entityTypes = assembly.GetTypes()
+                        .Where(type => TypeIsEntity(type));
+
+                    // 为每个找到的类型初始化数据库表
+                    foreach (var type in entityTypes)
+                    {
+                        _repository.GetDB().CodeFirst.InitTables(type);
+                    }
+                }
+                //安装向量插件
+                _repository.GetDB().Ado.ExecuteCommandAsync($"CREATE EXTENSION IF NOT EXISTS vector;");
+
+                _logger.LogInformation("初始化表结构完成");
+            }
+            return app;
+        }
+
+        public static WebApplication InitDbData(this WebApplication app)
+        {
+            using (var scope = app.Services.CreateScope())
+            {
+                // 初始化字典
+                var _dic_Repository = scope.ServiceProvider.GetRequiredService<IDics_Repositories>();
+                var llamafactoryStart = _dic_Repository.GetFirst(p => p.Type == LLamaFactoryConstantcs.LLamaFactorDic && p.Key == LLamaFactoryConstantcs.IsStartKey);
+                if (llamafactoryStart==null)
+                {
+                    llamafactoryStart = new Dics();
+                    llamafactoryStart.Id=Guid.NewGuid().ToString();
+                    llamafactoryStart.Type = LLamaFactoryConstantcs.LLamaFactorDic;
+                    llamafactoryStart.Key = LLamaFactoryConstantcs.IsStartKey;
+                    llamafactoryStart.Value = "false";
+                    _dic_Repository.Insert(llamafactoryStart);
+                }
+                _logger.LogInformation("初始化数据库初始数据完成");
+            }
+            return app;
+        }
+        /// <summary>
+        /// 加载数据库的插件
+        /// </summary>
+        /// <param name="services"></param>
+        /// <returns></returns>
+        public static WebApplication LoadFun(this WebApplication app)
+        {
+            try
+            {
+                using (var scope = app.Services.CreateScope())
+                {
+                    //codefirst 创建表
+                    var funRep = scope.ServiceProvider.GetRequiredService<IFuns_Repositories>();
+                    var functionService = scope.ServiceProvider.GetRequiredService<FunctionService>();
+                    var funs = funRep.GetList();
+                    foreach (var fun in funs)
+                    {
+                        functionService.FuncLoad(fun.Path);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex.Message + " ---- " + ex.StackTrace);
+            }
+            return app;
+        }
+        private static bool TypeIsEntity(Type type)
+        {
+            // 检查类型是否具有SugarTable特性
+            return type.GetCustomAttributes(typeof(SugarTable), inherit: false).Length > 0;
+        }
+
+        /// <summary>
+        /// swagger 初始化
+        /// </summary>
+        /// <param name="serviceCollection"></param>
+        /// <returns></returns>
+        public static IServiceCollection AddAntSKSwagger(this IServiceCollection serviceCollection)
+        {
+            serviceCollection.AddSwaggerGen(c =>
+            {
+                c.SwaggerDoc("v1", new() { Title = "AntSK.Api", Version = "v1" });
+                //添加Api层注释（true表示显示控制器注释）
+                var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
+                var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
+                c.IncludeXmlComments(xmlPath, true);
+                //添加Domain层注释（true表示显示控制器注释）
+                var xmlFile1 = $"{Assembly.GetExecutingAssembly().GetName().Name.Replace("Api", "Domain")}.xml";
+                var xmlPath1 = Path.Combine(AppContext.BaseDirectory, xmlFile1);
+                c.IncludeXmlComments(xmlPath1, true);
+                c.DocInclusionPredicate((docName, apiDes) =>
+                {
+                    if (!apiDes.TryGetMethodInfo(out MethodInfo method))
+                        return false;
+                    var version = method.DeclaringType.GetCustomAttributes(true).OfType<ApiExplorerSettingsAttribute>().Select(m => m.GroupName);
+                    if (docName == "v1" && !version.Any())
+                        return true;
+                    var actionVersion = method.GetCustomAttributes(true).OfType<ApiExplorerSettingsAttribute>().Select(m => m.GroupName);
+                    if (actionVersion.Any())
+                        return actionVersion.Any(v => v == docName);
+                    return version.Any(v => v == docName);
+                });
+                c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme()
+                {
+                    Description = "Directly enter bearer {token} in the box below (note that there is a space between bearer and token)",
+                    Name = "Authorization",
+                    In = ParameterLocation.Header,
+                    Type = SecuritySchemeType.ApiKey,
+                });
+                c.AddSecurityRequirement(new OpenApiSecurityRequirement
+                {
+                    {
+                        new OpenApiSecurityScheme
+                        {
+                            Reference = new OpenApiReference()
+                            {
+                                Id = "Bearer",
+                                Type = ReferenceType.SecurityScheme
+                            }
+                        }, Array.Empty<string>()
+                    }
+                });
+            });
+            return serviceCollection;
+        }
+    }
+}

src/AntSK.Domain/Common/Embedding/BuilderBgeExtensions.cs

@@ -0,0 +1,20 @@
+using Microsoft.KernelMemory.AI;
+using Microsoft.KernelMemory;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AntSK.Domain.Common.Embedding
+{
+    public static class BuilderBgeExtensions
+    {
+        public static IKernelMemoryBuilder WithBgeTextEmbeddingGeneration(this IKernelMemoryBuilder builder, HuggingfaceTextEmbeddingGenerator textEmbeddingGenerator)
+        {
+            builder.AddSingleton((ITextEmbeddingGenerator)textEmbeddingGenerator);
+            builder.AddIngestionEmbeddingGenerator(textEmbeddingGenerator);
+            return builder;
+        }
+    }
+}

src/AntSK.Domain/Common/Embedding/HuggingfaceTextEmbeddingGenerator.cs

@@ -0,0 +1,53 @@
+using Microsoft.KernelMemory.AI;
+using AntSK.Domain.Domain.Other.Bge;
+
+namespace AntSK.Domain.Common.Embedding
+{
+    public class HuggingfaceTextEmbeddingGenerator : ITextEmbeddingGenerator, ITextTokenizer, IDisposable
+    {
+        public int MaxTokens => 1024;
+
+        public int MaxTokenTotal => 1024;
+
+  
+        private readonly dynamic _embedder;
+
+        public HuggingfaceTextEmbeddingGenerator(string pyDllPath,string modelName)
+        {
+            _embedder = BgeEmbeddingConfig.LoadModel(pyDllPath, modelName);
+        }
+
+        public void Dispose()
+        {
+            BgeEmbeddingConfig.Dispose();
+        }
+
+        //public async Task<IList<ReadOnlyMemory<float>>> GenerateEmbeddingAsync(IList<string> data, CancellationToken cancellationToken = default)
+        //{
+        //    IList<ReadOnlyMemory<float>> results = new List<ReadOnlyMemory<float>>();
+
+        //    foreach (var d in data)
+        //    {
+        //        var embeddings = await EmbeddingConfig.GetEmbedding(d);
+        //        results.Add(new ReadOnlyMemory<float>(embeddings));
+        //    }
+        //    return results;
+        //}
+
+        public async Task<Microsoft.KernelMemory.Embedding> GenerateEmbeddingAsync(string text, CancellationToken cancellationToken = default)
+        {
+            var embeddings = await BgeEmbeddingConfig.GetEmbedding(text);
+            return new Microsoft.KernelMemory.Embedding(embeddings);
+        }
+
+        public int CountTokens(string text)
+        {
+            return BgeEmbeddingConfig.TokenCount(text);
+        }
+
+        public IReadOnlyList<string> GetTokens(string text)
+        {
+            return new List<string>();
+        }
+    }
+}

src/AntSK.Domain/Common/Excel/ExeclHelper.cs

@@ -0,0 +1,822 @@
+using NPOI.HSSF.UserModel;
+using NPOI.SS.UserModel;
+using NPOI.SS.Util;
+using NPOI.XSSF.Streaming;
+using NPOI.XSSF.UserModel;
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace AntSK.Domain
+{
+    public class ExeclHelper
+    {
+        /// <summary>
+        /// 将excel导入到datatable
+        /// </summary>
+        /// <param name="filePath">excel路径</param>
+        /// <param name="isColumnName">第一行是否是列名</param>
+        /// <returns>返回datatable</returns>
+        public static DataTable ExcelToDataTable(string filePath, bool isColumnName)
+        {
+            DataTable dataTable = null;
+            FileStream fs = null;
+            DataColumn column = null;
+            DataRow dataRow = null;
+            IWorkbook workbook = null;
+            ISheet sheet = null;
+            IRow row = null;
+            ICell cell = null;
+            int startRow = 0;
+            try
+            {
+                using (fs = File.OpenRead(filePath))
+                {
+                    // 2007版本
+                    if (filePath.Contains(".xlsx"))
+                        workbook = new XSSFWorkbook(fs);
+                    // 2003版本
+                    else if (filePath.Contains(".xls"))
+                        workbook = new HSSFWorkbook(fs);
+
+                    if (workbook != null)
+                    {
+                        sheet = workbook.GetSheetAt(0);//读取第一个sheet，当然也可以循环读取每个sheet
+                        dataTable = new DataTable();
+                        if (sheet != null)
+                        {
+                            int rowCount = sheet.LastRowNum;//总行数
+                            if (rowCount > 0)
+                            {
+                                IRow firstRow = sheet.GetRow(0);//第一行
+                                int cellCount = firstRow.LastCellNum;//列数
+
+                                //构建datatable的列
+                                if (isColumnName)
+                                {
+                                    startRow = 1;//如果第一行是列名，则从第二行开始读取
+                                    for (int i = firstRow.FirstCellNum; i < cellCount; ++i)
+                                    {
+                                        cell = firstRow.GetCell(i);
+                                        if (cell != null)
+                                        {
+                                            if (cell.StringCellValue != null)
+                                            {
+                                                column = new DataColumn(cell.StringCellValue);
+                                                dataTable.Columns.Add(column);
+                                            }
+                                        }
+                                    }
+                                }
+                                else
+                                {
+                                    for (int i = firstRow.FirstCellNum; i < cellCount; ++i)
+                                    {
+                                        column = new DataColumn("column" + (i + 1));
+                                        dataTable.Columns.Add(column);
+                                    }
+                                }
+
+                                //填充行
+                                for (int i = startRow; i <= rowCount; ++i)
+                                {
+                                    row = sheet.GetRow(i);
+                                    if (row == null) continue;
+
+                                    dataRow = dataTable.NewRow();
+                                    for (int j = row.FirstCellNum; j < cellCount; ++j)
+                                    {
+                                        cell = row.GetCell(j);
+                                        if (cell == null)
+                                        {
+                                            dataRow[j] = "";
+                                        }
+                                        else
+                                        {
+                                            //CellType(Unknown = -1,Numeric = 0,String = 1,Formula = 2,Blank = 3,Boolean = 4,Error = 5,)
+                                            switch (cell.CellType)
+                                            {
+                                                case CellType.Blank:
+                                                    dataRow[j] = "";
+                                                    break;
+                                                case CellType.Numeric:
+                                                    short format = cell.CellStyle.DataFormat;
+                                                    //对时间格式（2015.12.5、2015/12/5、2015-12-5等）的处理
+                                                    if (format == 14 || format == 31 || format == 57 || format == 58)
+                                                        dataRow[j] = cell.DateCellValue;
+                                                    else
+                                                        dataRow[j] = cell.NumericCellValue;
+                                                    break;
+                                                case CellType.String:
+                                                    dataRow[j] = cell.StringCellValue;
+                                                    break;
+                                            }
+                                        }
+                                    }
+                                    dataTable.Rows.Add(dataRow);
+                                }
+                            }
+                        }
+                    }
+                }
+                return dataTable;
+            }
+            catch (Exception)
+            {
+                if (fs != null)
+                {
+                    fs.Close();
+                }
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// 将excel导入到datatable
+        /// </summary>
+        /// <param name="stream">流</param>
+        /// <param name="isColumnName">第一行是否是列名</param>
+        /// <returns></returns>
+        public static DataTable ExcelToDataTable(Stream stream, bool isColumnName)
+        {
+            DataTable dataTable = null;
+            DataColumn column = null;
+            DataRow dataRow = null;
+            IWorkbook workbook = new XSSFWorkbook(stream);
+            ISheet sheet = null;
+            IRow row = null;
+            ICell cell = null;
+            int startRow = 0;
+            try
+            {
+
+                if (workbook != null)
+                {
+                    sheet = workbook.GetSheetAt(0);//读取第一个sheet，当然也可以循环读取每个sheet
+                    dataTable = new DataTable();
+                    if (sheet != null)
+                    {
+                        int rowCount = sheet.LastRowNum;//总行数
+                        if (rowCount > 0)
+                        {
+                            IRow firstRow = sheet.GetRow(0);//第一行
+                            int cellCount = firstRow.LastCellNum;//列数
+
+                            //构建datatable的列
+                            if (isColumnName)
+                            {
+                                startRow = 1;//如果第一行是列名，则从第二行开始读取
+                                for (int i = firstRow.FirstCellNum; i < cellCount; ++i)
+                                {
+                                    cell = firstRow.GetCell(i);
+                                    if (cell != null)
+                                    {
+                                        if (cell.StringCellValue != null)
+                                        {
+                                            column = new DataColumn(cell.StringCellValue);
+                                            dataTable.Columns.Add(column);
+                                        }
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                for (int i = firstRow.FirstCellNum; i < cellCount; ++i)
+                                {
+                                    column = new DataColumn("column" + (i + 1));
+                                    dataTable.Columns.Add(column);
+                                }
+                            }
+
+                            //填充行
+                            for (int i = startRow; i <= rowCount; ++i)
+                            {
+                                row = sheet.GetRow(i);
+                                if (row == null) continue;
+
+                                dataRow = dataTable.NewRow();
+                                for (int j = row.FirstCellNum; j < cellCount; ++j)
+                                {
+                                    cell = row.GetCell(j);
+                                    if (cell == null)
+                                    {
+                                        dataRow[j] = "";
+                                    }
+                                    else
+                                    {
+                                        //CellType(Unknown = -1,Numeric = 0,String = 1,Formula = 2,Blank = 3,Boolean = 4,Error = 5,)
+                                        switch (cell.CellType)
+                                        {
+                                            case CellType.Blank:
+                                                dataRow[j] = "";
+                                                break;
+                                            case CellType.Numeric:
+                                                short format = cell.CellStyle.DataFormat;
+                                                //对时间格式（2015.12.5、2015/12/5、2015-12-5等）的处理
+                                                if (format == 14 || format == 31 || format == 57 || format == 58)
+                                                    dataRow[j] = cell.DateCellValue;
+                                                else
+                                                    dataRow[j] = cell.NumericCellValue;
+                                                break;
+                                            case CellType.String:
+                                                dataRow[j] = cell.StringCellValue;
+                                                break;
+                                        }
+                                    }
+                                }
+                                dataTable.Rows.Add(dataRow);
+                            }
+                        }
+                    }
+                }
+
+                return dataTable;
+            }
+            catch (Exception)
+            {
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// excel转list
+        /// </summary>
+        /// <typeparam name="TResult"></typeparam>
+        /// <param name="stream"></param>
+        /// <returns></returns>
+        public static IEnumerable<TResult> ExcelToList<TResult>(Stream stream) where TResult : new()
+        {
+            var propertyInfos = typeof(TResult).GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(p => p.CustomAttributes.Count() > 0)
+                .OrderBy(p => p.GetCustomAttribute<ExeclPropertyAttribute>().Order).ToArray();
+
+            List<TResult> list = new List<TResult>();
+
+            IWorkbook workbook = new XSSFWorkbook(stream);
+            ISheet sheet = null;
+            IRow row = null;
+            ICell cell = null;
+            int startRow = 1;
+            try
+            {
+
+                if (workbook != null)
+                {
+                    sheet = workbook.GetSheetAt(0);//读取第一个sheet，当然也可以循环读取每个sheet
+                    if (sheet != null)
+                    {
+                        int rowCount = sheet.LastRowNum;//总行数
+                        if (rowCount > 0)
+                        {
+                            IRow firstRow = sheet.GetRow(0);//第一行
+                            int cellCount = firstRow.LastCellNum;//列数
+
+                            //填充行
+                            for (int i = startRow; i <= rowCount; ++i)
+                            {
+                                row = sheet.GetRow(i);
+                                if (row == null) continue;
+                                bool emptyRow = true;//是否空行
+                                TResult dataModel = new TResult();
+
+                                for (int j = row.FirstCellNum; j < cellCount; ++j)
+                                {
+                                    var execlPropertyAttribute = propertyInfos[j].GetCustomAttribute<ExeclPropertyAttribute>();
+
+                                    cell = row.GetCell(j);
+                                    if (cell == null)
+                                    {
+                                        propertyInfos[j].SetValue(dataModel, "");
+                                    }
+                                    else
+                                    {
+                                        switch (cell.CellType)
+                                        {
+                                            case CellType.Blank:
+                                                propertyInfos[j].SetValue(dataModel, "");
+                                                break;
+                                            case CellType.Numeric:
+                                                short format = cell.CellStyle.DataFormat;
+                                                //对时间格式（2015.12.5、2015/12/5、2015-12-5等）的处理
+                                                if (format == 14 || format == 31 || format == 57 || format == 58)
+                                                    propertyInfos[j].SetValue(dataModel, cell.DateCellValue);
+                                                else
+                                                {
+                                                    if (execlPropertyAttribute.CellType == CellType.String)
+                                                    {
+                                                        propertyInfos[j].SetValue(dataModel, cell.NumericCellValue.ToString());
+                                                    }
+                                                    else
+
+                                                    {
+                                                        propertyInfos[j].SetValue(dataModel, cell.NumericCellValue);
+                                                    }
+                                                }
+                                                break;
+                                            case CellType.String:
+                                                propertyInfos[j].SetValue(dataModel, cell.StringCellValue);
+                                                break;
+                                        }
+                                    }
+
+                                    if (cell != null && !string.IsNullOrEmpty(cell.ToString().Trim()))
+                                    {
+                                        emptyRow = false;
+                                    }
+                                }
+                                //非空数据行数据添加到DataTable
+                                if (!emptyRow)
+                                {
+                                    list.Add(dataModel);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return list;
+            }
+            catch (Exception)
+            {
+                throw;
+            }
+        }
+
+
+        public static IEnumerable<TResult> ExcelToListFileName<TResult>(Stream stream, string fileName) where TResult : new()
+        {
+            var propertyInfos = typeof(TResult).GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(p => p.CustomAttributes.Count() > 0)
+                .OrderBy(p => p.GetCustomAttribute<ExeclPropertyAttribute>().Order).ToArray();
+
+            List<TResult> list = new List<TResult>();
+
+            IWorkbook workbook = null;
+            if (fileName.Contains(".xlsx"))
+                workbook = new XSSFWorkbook(stream);
+            // 2003版本
+            else if (fileName.Contains(".xls"))
+                workbook = new HSSFWorkbook(stream);
+            ISheet sheet = null;
+            IRow row = null;
+            ICell cell = null;
+            int startRow = 1;
+            try
+            {
+
+                if (workbook != null)
+                {
+                    sheet = workbook.GetSheetAt(0);//读取第一个sheet，当然也可以循环读取每个sheet
+                    if (sheet != null)
+                    {
+                        int rowCount = sheet.LastRowNum;//总行数
+                        if (rowCount > 0)
+                        {
+                            IRow firstRow = sheet.GetRow(0);//第一行
+                            int cellCount = firstRow.LastCellNum;//列数
+
+                            //填充行
+                            for (int i = startRow; i <= rowCount; ++i)
+                            {
+                                row = sheet.GetRow(i);
+                                if (row == null) continue;
+                                bool emptyRow = true;//是否空行
+                                TResult dataModel = new TResult();
+
+                                for (int j = row.FirstCellNum; j < cellCount; ++j)
+                                {
+                                    var execlPropertyAttribute = propertyInfos[j].GetCustomAttribute<ExeclPropertyAttribute>();
+
+                                    cell = row.GetCell(j);
+                                    if (cell == null)
+                                    {
+                                        propertyInfos[j].SetValue(dataModel, "");
+                                    }
+                                    else
+                                    {
+                                        switch (cell.CellType)
+                                        {
+                                            case CellType.Blank:
+                                                propertyInfos[j].SetValue(dataModel, "");
+                                                break;
+                                            case CellType.Numeric:
+                                                short format = cell.CellStyle.DataFormat;
+                                                //对时间格式（2015.12.5、2015/12/5、2015-12-5等）的处理
+                                                if (format == 14 || format == 31 || format == 57 || format == 58)
+                                                    propertyInfos[j].SetValue(dataModel, cell.DateCellValue);
+                                                else
+                                                {
+                                                    if (execlPropertyAttribute.CellType == CellType.String)
+                                                    {
+                                                        propertyInfos[j].SetValue(dataModel, cell.NumericCellValue.ToString());
+                                                    }
+                                                    else
+
+                                                    {
+                                                        propertyInfos[j].SetValue(dataModel, cell.NumericCellValue);
+                                                    }
+                                                }
+                                                break;
+                                            case CellType.String:
+                                                propertyInfos[j].SetValue(dataModel, cell.StringCellValue);
+                                                break;
+                                        }
+                                    }
+
+                                    if (cell != null && !string.IsNullOrEmpty(cell.ToString().Trim()))
+                                    {
+                                        emptyRow = false;
+                                    }
+                                }
+                                //非空数据行数据添加到DataTable
+                                if (!emptyRow)
+                                {
+                                    list.Add(dataModel);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return list;
+            }
+            catch (Exception)
+            {
+                throw;
+            }
+        }
+        /// <summary>
+        /// excel转list-根据sheetName得到List
+        /// </summary>
+        /// <typeparam name="TResult"></typeparam>
+        /// <param name="stream"></param>
+        /// <param name="sheetName"></param>
+        /// <returns></returns>
+        public static IEnumerable<TResult> ExcelToList<TResult>(Stream stream, string sheetName) where TResult : new()
+        {
+            var propertyInfos = typeof(TResult).GetProperties(BindingFlags.Public | BindingFlags.Instance)
+                .OrderBy(p => p.GetCustomAttribute<ExeclPropertyAttribute>().Order).ToArray();
+
+            List<TResult> list = new List<TResult>();
+
+            IWorkbook workbook = new XSSFWorkbook(stream);
+            ISheet sheet = null;
+            IRow row = null;
+            ICell cell = null;
+            int startRow = 1;
+            try
+            {
+
+                if (workbook != null)
+                {
+                    sheet = workbook.GetSheet(sheetName);//根据sheet读取对应的DataTable
+                    if (sheet != null)
+                    {
+                        int rowCount = sheet.LastRowNum;//总行数
+                        if (rowCount > 0)
+                        {
+                            IRow firstRow = sheet.GetRow(0);//第一行
+                            int cellCount = firstRow.LastCellNum;//列数
+
+                            //填充行
+                            for (int i = startRow; i <= rowCount; ++i)
+                            {
+                                row = sheet.GetRow(i);
+                                if (row == null) continue;
+                                bool emptyRow = true;//是否空行
+
+                                TResult dataModel = new TResult();
+
+                                for (int j = row.FirstCellNum; j < cellCount; ++j)
+                                {
+                                    var execlPropertyAttribute = propertyInfos[j].GetCustomAttribute<ExeclPropertyAttribute>();
+
+                                    cell = row.GetCell(j);
+                                    if (cell == null)
+                                    {
+                                        propertyInfos[j].SetValue(dataModel, "");
+                                    }
+                                    else
+                                    {
+                                        switch (cell.CellType)
+                                        {
+                                            case CellType.Blank:
+                                                propertyInfos[j].SetValue(dataModel, "");
+                                                break;
+                                            case CellType.Numeric:
+                                                short format = cell.CellStyle.DataFormat;
+                                                //对时间格式（2015.12.5、2015/12/5、2015-12-5等）的处理
+                                                if (format == 14 || format == 31 || format == 57 || format == 58)
+                                                    propertyInfos[j].SetValue(dataModel, cell.DateCellValue);
+                                                else
+                                                {
+                                                    if (execlPropertyAttribute.CellType == CellType.String)
+                                                    {
+                                                        propertyInfos[j].SetValue(dataModel, cell.NumericCellValue.ToString());
+                                                    }
+                                                    else
+
+                                                    {
+                                                        propertyInfos[j].SetValue(dataModel, cell.NumericCellValue);
+                                                    }
+
+                                                }
+                                                break;
+                                            case CellType.String:
+                                                propertyInfos[j].SetValue(dataModel, cell.StringCellValue);
+                                                break;
+                                        }
+                                    }
+                                    if (cell != null && !string.IsNullOrEmpty(cell.ToString().Trim()))
+                                    {
+                                        emptyRow = false;
+                                    }
+                                }
+                                //非空数据行数据添加到DataTable
+                                if (!emptyRow)
+                                {
+                                    list.Add(dataModel);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return list;
+            }
+            catch (Exception ex)
+            {
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// List导出excel 二进制流
+        /// </summary>
+        /// <typeparam name="T">实体</typeparam>
+        /// <param name="data">List</param>
+        /// <param name="sheetName">sheetname 可不填，默认Sheet0</param>
+        /// <returns></returns>
+        public static byte[] ListToExcel<T>(T[] data, string sheetName = "Sheet0")
+        {
+            IWorkbook workbook = null;
+            IRow row = null;
+            ISheet sheet = null;
+            ICell cell = null;
+            var propertyInfos = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)
+                   .OrderBy(p => p.GetCustomAttribute<ExeclPropertyAttribute>().Order).ToArray();
+            workbook = new XSSFWorkbook();
+            sheet = workbook.CreateSheet(sheetName);//创建一个名称为Sheet0的表
+            int rowCount = data.Count();//行数
+            int columnCount = propertyInfos.Length;//列数
+            //设置列头
+            row = sheet.CreateRow(0);//excel第一行设为列头
+            for (int c = 0; c < columnCount; c++)
+            {
+                cell = row.CreateCell(c);
+                cell.SetCellValue(propertyInfos[c].GetCustomAttribute<ExeclPropertyAttribute>().DisplayName);
+            }
+            //设置每行每列的单元格,
+            for (int i = 0; i < rowCount; i++)
+            {
+                row = sheet.CreateRow(i + 1);
+                for (int j = 0; j < columnCount; j++)
+                {
+                    cell = row.CreateCell(j);//excel第二行开始写入数据
+                    cell.SetCellValue(propertyInfos[j].GetValue(data[i])?.ToString());
+                }
+            }
+            using (MemoryStream memoryStream = new MemoryStream())
+            {
+                workbook.Write(memoryStream);//向打开的这个xls文件中写入数据
+                return memoryStream.ToArray();
+            }
+        }
+
+        /// <summary>
+        ///  Dt导出excel 二进制流
+        /// </summary>
+        /// <param name="dt">datatable</param>
+        /// <param name="strFile">strFile</param>
+        /// <returns></returns>
+        public static byte[] DataTableToExcel(DataTable dt, string strFile, string sheetName = "Sheet0")
+        {
+            bool result = false;
+            IWorkbook workbook = null;
+            FileStream fs = null;
+            IRow row = null;
+            ISheet sheet = null;
+            ICell cell = null;
+
+            if (dt != null && dt.Rows.Count > 0)
+            {
+                workbook = new XSSFWorkbook();
+                sheet = workbook.CreateSheet(sheetName);//创建一个名称为Sheet0的表
+                int rowCount = dt.Rows.Count;//行数
+                int columnCount = dt.Columns.Count;//列数
+
+                //设置列头
+                row = sheet.CreateRow(0);//excel第一行设为列头
+                for (int c = 0; c < columnCount; c++)
+                {
+                    cell = row.CreateCell(c);
+                    cell.SetCellValue(dt.Columns[c].ColumnName);
+                }
+
+                //设置每行每列的单元格,
+                for (int i = 0; i < rowCount; i++)
+                {
+                    row = sheet.CreateRow(i + 1);
+                    for (int j = 0; j < columnCount; j++)
+                    {
+                        cell = row.CreateCell(j);//excel第二行开始写入数据
+                        cell.SetCellValue(dt.Rows[i][j].ToString());
+                    }
+                }
+                using (MemoryStream memoryStream = new MemoryStream())
+                {
+                    workbook.Write(memoryStream);//向打开的这个xls文件中写入数据
+                    return memoryStream.ToArray();
+                }
+            }
+            else
+            {
+                return new byte[0];
+            }
+        }
+
+        /// <summary>
+        /// List写入excel
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="data"></param>
+        /// <param name="strFile">路径</param>
+        /// <param name="sheetName"></param>
+        /// <returns></returns>
+        public static bool ListWriteExcel<T>(T[] data, string strFile, string sheetName = "Sheet0")
+        {
+            bool result = false;
+            IWorkbook workbook = null;
+            FileStream fs = null;
+            IRow row = null;
+            ISheet sheet = null;
+            ICell cell = null;
+            try
+            {
+                var propertyInfos = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)
+                       .OrderBy(p => p.GetCustomAttribute<ExeclPropertyAttribute>().Order).ToArray();
+                workbook = new XSSFWorkbook();
+                sheet = workbook.CreateSheet(sheetName);//创建一个名称为Sheet0的表
+                int rowCount = data.Count();//行数
+                int columnCount = propertyInfos.Length;//列数
+                                                       //设置列头
+                row = sheet.CreateRow(0);//excel第一行设为列头
+                for (int c = 0; c < columnCount; c++)
+                {
+                    cell = row.CreateCell(c);
+                    cell.SetCellValue(propertyInfos[c].GetCustomAttribute<ExeclPropertyAttribute>().DisplayName);
+                }
+                //设置每行每列的单元格,
+                for (int i = 0; i < rowCount; i++)
+                {
+                    row = sheet.CreateRow(i + 1);
+                    for (int j = 0; j < columnCount; j++)
+                    {
+                        cell = row.CreateCell(j);//excel第二行开始写入数据
+                        cell.SetCellValue(propertyInfos[j].GetValue(data[i])?.ToString());
+                    }
+                }
+                using (fs = File.OpenWrite(strFile))
+                {
+                    workbook.Write(fs);//向打开的这个xls文件中写入数据
+                    result = true;
+                }
+                return result;
+            }
+            catch (Exception ex)
+            {
+                if (fs != null)
+                {
+                    fs.Close();
+                }
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// dt写入excel
+        /// </summary>
+        /// <param name="dt">datatable</param>
+        /// <param name="strFile">路径</param>
+        /// <returns></returns>
+        public static bool DataTableWriteExcel(DataTable dt, string strFile, string sheetName = "Sheet0")
+        {
+            bool result = false;
+            IWorkbook workbook = null;
+            FileStream fs = null;
+            IRow row = null;
+            ISheet sheet = null;
+            ICell cell = null;
+            try
+            {
+                if (dt != null && dt.Rows.Count > 0)
+                {
+                    workbook = new XSSFWorkbook();
+                    sheet = workbook.CreateSheet(sheetName);//创建一个名称为Sheet0的表
+                    int rowCount = dt.Rows.Count;//行数
+                    int columnCount = dt.Columns.Count;//列数
+
+                    //设置列头
+                    row = sheet.CreateRow(0);//excel第一行设为列头
+                    for (int c = 0; c < columnCount; c++)
+                    {
+                        cell = row.CreateCell(c);
+                        cell.SetCellValue(dt.Columns[c].ColumnName);
+                    }
+
+                    //设置每行每列的单元格,
+                    for (int i = 0; i < rowCount; i++)
+                    {
+                        row = sheet.CreateRow(i + 1);
+                        for (int j = 0; j < columnCount; j++)
+                        {
+                            cell = row.CreateCell(j);//excel第二行开始写入数据
+                            cell.SetCellValue(dt.Rows[i][j].ToString());
+                        }
+                    }
+                    using (fs = File.OpenWrite(strFile))
+                    {
+                        workbook.Write(fs);//向打开的这个xls文件中写入数据
+                        result = true;
+                    }
+                }
+                return result;
+            }
+            catch (Exception ex)
+            {
+                if (fs != null)
+                {
+                    fs.Close();
+                }
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 设置单元格下拉框(除去标题行)
+        /// </summary>
+        /// <param name="workbook"></param>
+        /// <param name="sheet"></param>
+        /// <param name="ddlList"></param>
+        /// <param name="firstcol"></param>
+        /// <param name="lastcol"></param>
+        public static void SetCellDropdownList(IWorkbook workbook, ISheet sheet, List<string> ddlList, string sheetname, int sheetIndex, int firstcol, int lastcol)
+        {
+
+            # region 低版本Excel【HSSFWorkbook】设置下拉框
+            //ISheet sheet2 = workbook.CreateSheet(sheetname);
+
+            ////隐藏
+            //workbook.SetSheetHidden(sheetIndex, 1);
+            //int rowIndex = 0;
+            //foreach (var item in ddlList)
+            //{
+            //    IRow vrow = sheet2.CreateRow(rowIndex);
+            //    vrow.CreateCell(0).SetCellValue(item);
+
+            //    rowIndex++;
+            //}
+
+            ////创建的下拉项的区域：
+            //var rangeName = sheetname + "Range";
+            //IName range = workbook.CreateName();
+            //range.RefersToFormula = sheetname + "!$A$1:$A$" + rowIndex;
+            //range.NameName = rangeName;
+            //CellRangeAddressList regions = new CellRangeAddressList(1, 65535, firstcol, lastcol);
+
+            //DVConstraint constraint = DVConstraint.CreateFormulaListConstraint(rangeName);
+            //HSSFDataValidation dataValidate = new HSSFDataValidation(regions, constraint);
+            //dataValidate.CreateErrorBox("输入不合法", "请输入或选择下拉列表中的值。");
+            //dataValidate.ShowPromptBox = true;
+            //sheet.AddValidationData(dataValidate);
+            #endregion
+
+            //高版本excel【XSSFWorkbook】 设置下拉框
+            XSSFSheet sheetDDL = (XSSFSheet)workbook.CreateSheet(sheetname);
+            workbook.SetSheetHidden(sheetIndex, 1); //隐藏下拉框数据sheet
+            String[] datas = ddlList.ToArray(); //下拉框数据源
+            XSSFDataValidationHelper dvHelper = new XSSFDataValidationHelper(sheetDDL);
+            XSSFDataValidationConstraint dvConstraint = (XSSFDataValidationConstraint)dvHelper.CreateExplicitListConstraint(datas);
+            CellRangeAddressList addressList = new CellRangeAddressList(1, 65535, firstcol, lastcol); //下拉设置列
+            XSSFDataValidation validation = (XSSFDataValidation)dvHelper.CreateValidation(dvConstraint, addressList);
+
+            validation.SuppressDropDownArrow = true;
+            validation.ShowErrorBox = true;
+            validation.ShowPromptBox = true;
+            sheet.AddValidationData(validation);
+
+        }
+    }
+}

src/AntSK.Domain/Common/Excel/ExeclPropertyAttribute.cs

@@ -0,0 +1,28 @@
+using NPOI.SS.UserModel;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace AntSK.Domain
+{
+    public class ExeclPropertyAttribute : Attribute
+    {
+        public ExeclPropertyAttribute()
+        {
+
+        }
+        public ExeclPropertyAttribute(string displayName, int order, CellType cellType = CellType.String)
+        {
+            DisplayName = displayName;
+            Order = order;
+            CellType = cellType;
+        }
+
+        public string DisplayName { get; set; }
+
+        public int Order { get; set; }
+
+        public CellType CellType { get; set; }
+    }
+}

src/AntSK.Domain/Common/LLamaFactory/ProcessWrapper.cs

@@ -0,0 +1,73 @@
+using Amazon.Runtime.Internal.Util;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AntSK.Domain.Common.LLamaFactory
+{
+    public class ProcessWrapper(ILogger<ProcessWrapper> _logger)
+    {
+        private Process process;
+
+        public static bool isProcessComplete = false;
+
+
+        public void StartProcess(string arguments, string workingDirectory)
+        {
+            process =  new Process
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    FileName = "python",
+                    Arguments = arguments,
+                    UseShellExecute = false,
+                    RedirectStandardOutput = true,
+                    RedirectStandardError = true,
+                    CreateNoWindow = true,
+                    WorkingDirectory = workingDirectory
+                }
+            };
+            using (Process start = Process.Start(process.StartInfo))
+            {
+                using (StreamReader reader = start.StandardOutput)
+                {
+                    string result = reader.ReadToEnd();
+                    if (result != null)
+                    {
+                        if (result.Contains(":8000"))
+                        {
+                            isProcessComplete = true;
+                        }
+                    }
+                    _logger.LogInformation(result);
+                }
+                start.WaitForExit();
+            }
+        }
+
+        public string WaitForProcessExit()
+        {
+            process.WaitForExit();
+            return process.StandardOutput.ReadToEnd();
+        }
+
+        public void KillProcess()
+        {
+            try
+            {
+                if (!process.HasExited)
+                {
+                    process.Kill();
+                }
+            }
+            catch (InvalidOperationException)
+            {
+                // Process already exited.
+            }
+        }
+    }
+}

src/AntSK.Domain/Domain/Dto/RelevantSource.cs

@@ -1,16 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace AntSK.Domain.Domain.Dto
-{
-    public class RelevantSource
-    {
-        public string SourceName { get; set; }
-
-        public string Text { get; set; }
-        public float Relevance { get; set; }
-    }
-}

src/AntSK.Domain/Domain/Interface/IChatService.cs

@@ -1,8 +1,11 @@
-using AntSK.Domain.Domain.Dto;
+using AntSK.Domain.Domain.Model;
+using AntSK.Domain.Domain.Model.Dto;
 using AntSK.Domain.Repositories;
 using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.ChatCompletion;
 using System;
 using System.Collections.Generic;
+using System.Drawing;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -11,8 +14,10 @@ namespace AntSK.Domain.Domain.Interface
 {
     public interface IChatService
     {
-        IAsyncEnumerable<StreamingKernelContent> SendChatByAppAsync(Apps app, string questions, string history);
+        IAsyncEnumerable<string> SendChatByAppAsync(Apps app, ChatHistory history);
 
-        IAsyncEnumerable<StreamingKernelContent> SendKmsByAppAsync(Apps app, string questions, string history, List<RelevantSource> relevantSources = null);
+        IAsyncEnumerable<StreamingKernelContent> SendKmsByAppAsync(Apps app, string questions, ChatHistory history, string filePath, List<RelevantSource> relevantSources = null);
+        Task<string> SendImgByAppAsync(Apps app, string questions);
+        Task<ChatHistory> GetChatHistory(List<Chats> MessageList, ChatHistory history);
     }
-}
+}

src/AntSK.Domain/Domain/Interface/IImportKMSService.cs

@@ -1,4 +1,4 @@
-using AntSK.Domain.Model;
+using AntSK.Domain.Domain.Model;
 
 namespace AntSK.Domain.Domain.Interface
 {

src/AntSK.Domain/Domain/Interface/IKMService.cs

@@ -1,11 +1,24 @@
-using AntSK.Domain.Domain.Dto;
+using AntDesign;
+using AntSK.Domain.Domain.Model.Dto;
+using AntSK.Domain.Repositories;
 using Microsoft.KernelMemory;
 
 namespace AntSK.Domain.Domain.Interface
 {
     public interface IKMService
     {
-        MemoryServerless GetMemoryByKMS(string kmsID, SearchClientConfig searchClientConfig = null);
-        Task<List<KMFile>> GetDocumentByFileID(string kmsid, string fileid);
+        MemoryServerless GetMemoryByApp(Apps app);
+
+        MemoryServerless GetMemoryByKMS(string kmsID);
+
+        Task<List<KMFile>> GetDocumentByFileID(string kmsId, string fileId);
+
+        Task<List<RelevantSource>> GetRelevantSourceList(Apps app, string msg);
+
+        List<UploadFileItem> FileList { get; }
+
+        bool BeforeUpload(UploadFileItem file);
+
+        void OnSingleCompleted(UploadInfo fileinfo);
     }
-}
+}

src/AntSK.Domain/Domain/Interface/IKernelService.cs

@@ -6,6 +6,8 @@ namespace AntSK.Domain.Domain.Interface
     public interface IKernelService
     {
         Kernel GetKernelByApp(Apps app);
+
+        Kernel GetKernelByAIModelID(string modelid);
         void ImportFunctionsByApp(Apps app, Kernel _kernel);
         Task<string> HistorySummarize(Kernel _kernel, string questions, string history);
     }

src/AntSK.Domain/Domain/Interface/ILLamaFactoryService.cs

@@ -0,0 +1,23 @@
+using AntSK.LLamaFactory.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static AntSK.Domain.Domain.Service.LLamaFactoryService;
+
+namespace AntSK.Domain.Domain.Interface
+{
+    public interface ILLamaFactoryService
+    {
+        public event LogMessageHandler LogMessageReceived;
+        Task PipInstall();
+
+        Task PipInstallName(string name);
+        Task StartLLamaFactory(string modelName);
+
+        void KillProcess();
+
+        List<LLamaModel> GetLLamaFactoryModels();
+    }
+}

src/AntSK.Domain/Domain/Interface/IOllamaService.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static AntSK.Domain.Domain.Service.OllamaService;
+
+namespace AntSK.Domain.Domain.Interface
+{
+    public interface IOllamaService
+    {
+        public event LogMessageHandler LogMessageReceived;
+        Task StartOllama(string modelName);
+    }
+}

src/AntSK.Domain/Domain/Model/Constant/KmsConstantcs.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AntSK.Domain.Domain.Model.Constant
+{
+    public class KmsConstantcs
+    {
+        public const string KmsIdTag = "kmsid";
+        public const string FileIdTag = "fileid";
+        public const string AppIdTag = "appid";
+        public const string KmsIndex = "kms";
+        public const string FileIndex = "kms";
+        public const string KmsSearchNull="知识库未搜索到相关内容";
+
+        public const string KmsPrompt = @"使用<data></data>标记的内容作为你的知识：
+<data>
+{{$doc}}
+</data>
+--------------------------
+回答要求：
+- 如果你不清楚答案，你需要澄清
+- 避免提及你是从<data></data>获取的知识
+- 保持答案与<data></data>众描述一致
+- 使用Markdown语法优化回答格式。
+- 如果Markdown有图片则正常显示
+--------------------------
+
+历史聊天记录:{{ConversationSummaryPlugin.SummarizeConversation $history}}
+--------------------------
+用户问题: {{$input}}";
+
+        public const string KMExcelSplit = "*&antsk_excel&*";
+    }
+}

src/AntSK.Domain/Domain/Model/Constant/LLamaFactoryConstantcs.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AntSK.Domain.Domain.Model.Constant
+{
+    public class LLamaFactoryConstantcs
+    {
+        public const string LLamaFactorDic = "llamafactory";
+        public const string IsStartKey = "isstart";
+    }
+}

src/AntSK.Domain/Domain/Model/Dto/KMFile.cs

@@ -1,15 +1,14 @@
-namespace AntSK.Domain.Domain.Dto
+namespace AntSK.Domain.Domain.Model.Dto
 {
     public class KMFile
     {
+        public string DocumentId { get; set; }
         public string Text { get; set; }
 
-        public string Url { get; set; }
+        public string? Url { get; set; }
 
         public string LastUpdate { get; set; }
 
-        public string Schema { get; set; }
-
         public string File { get; set; }
     }
-}
+}

src/AntSK.Domain/Domain/Model/Dto/OpenAPI/OpenAIModel.cs

@@ -1,4 +1,4 @@
-namespace AntSK.Domain.Domain.Dto
+namespace AntSK.Domain.Domain.Model.Dto.OpenAPI
 {
     public class OpenAIModel
     {

src/AntSK.Domain/Domain/Model/Dto/OpenAPI/OpenAIResult.cs

@@ -1,6 +1,6 @@
 using Newtonsoft.Json;
 
-namespace AntSK.Domain.Domain.Dto
+namespace AntSK.Domain.Domain.Model.Dto.OpenAPI
 {
     public class OpenAIResult
     {

src/AntSK.Domain/Domain/Model/Dto/RelevantSource.cs

@@ -0,0 +1,18 @@
+
+namespace AntSK.Domain.Domain.Model.Dto
+{
+    public class RelevantSource
+    {
+        public string SourceName { get; set; }
+
+        public string Text { get; set; }
+        public float Relevance { get; set; }
+
+        public double RerankScore { get; set; }
+
+        public override string ToString()
+        {
+            return $"[file:{SourceName};Relevance:{(Relevance * 100):F2}%]:{Text}";
+        }
+    }
+}

src/AntSK.Domain/Domain/Model/Enum/AIModelType.cs

@@ -0,0 +1,47 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace AntSK.Domain.Domain.Model.Enum
+{
+    /// <summary>
+    /// AI类型
+    /// </summary>
+    public enum AIType
+    {
+        [Display(Name = "Open AI")]
+        OpenAI = 1,
+
+        [Display(Name = "Azure Open AI")]
+        AzureOpenAI = 2,
+
+        [Display(Name = "星火大模型")]
+        SparkDesk = 4,
+
+        [Display(Name = "灵积大模型")]
+        DashScope = 5,
+
+        [Display(Name = "LLamaFactory")]
+        LLamaFactory = 6,
+        [Display(Name = "Bge Embedding")]
+        BgeEmbedding = 7,
+        [Display(Name = "Bge Rerank")]
+        BgeRerank = 8,
+
+        [Display(Name = "Ollama")]
+        Ollama = 10,
+        [Display(Name = "OllamaEmbedding")]
+        OllamaEmbedding = 11,
+        [Display(Name = "模拟输出")]
+        Mock = 100,
+
+    }
+
+    /// <summary>
+    /// 模型类型
+    /// </summary>
+    public enum AIModelType
+    {
+        Chat = 1,
+        Embedding = 2,
+        Rerank=4
+    }
+}

src/AntSK.Domain/Domain/Model/Enum/AppType.cs

@@ -4,11 +4,12 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace AntSK.Domain.Model.Enum
+namespace AntSK.Domain.Domain.Model.Enum
 {
     public enum AppType
     {
-        chat=1,
-        kms=2
+        chat = 1,
+        kms = 2,
+        img=3
     }
 }

src/AntSK.Domain/Domain/Model/Enum/HttpMethodType.cs

@@ -1,4 +1,4 @@
-namespace AntSK.Domain.Model
+namespace AntSK.Domain.Domain.Model.Enum
 {
     public enum HttpMethodType
     {

src/AntSK.Domain/Domain/Model/Enum/ImportKmsStatus.cs

@@ -1,4 +1,4 @@
-namespace AntSK.Domain.Model.Enum
+namespace AntSK.Domain.Domain.Model.Enum
 {
     public enum ImportKmsStatus
     {

src/AntSK.Domain/Domain/Model/Excel/KMSExcelModel.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AntSK.Domain.Domain.Model.Excel
+{
+    public class KMSExcelModel
+    {
+        [ExeclProperty("问题",0)]
+        public string Question { get; set; }
+
+        [ExeclProperty("答案", 1)]
+        public string Answer { get; set; }
+    }
+}

src/AntSK.Domain/Domain/Model/Fun/FunDto.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AntSK.Domain.Domain.Model.Fun
+{
+    public class FunDto
+    {
+        public string Name { get; set; }
+
+        public string Description { get; set; }
+
+        public FunType FunType { get; set; }
+    }
+
+    public enum FunType
+    {
+        System=1,
+        Import=2
+    }
+}

src/AntSK.Domain/Domain/Model/ImportKMSTaskReq.cs

@@ -1,6 +1,6 @@
 using AntSK.Domain.Repositories;
 
-namespace AntSK.Domain.Model
+namespace AntSK.Domain.Domain.Model
 {
     public class ImportKMSTaskDTO
     {
@@ -17,11 +17,14 @@ namespace AntSK.Domain.Model
         public string FilePath { get; set; } = "";
 
         public string FileName { get; set; } = "";
+
+        public bool IsQA { get; set; } = false;
     }
 
 
     public class ImportKMSTaskReq : ImportKMSTaskDTO
     {
+        public bool IsQA { get; set; }=false;
         public KmsDetails KmsDetail { get; set; } = new KmsDetails();
     }
 
@@ -29,6 +32,13 @@ namespace AntSK.Domain.Model
     {
         File = 1,
         Url = 2,
-        Text = 3
+        Text = 3,
+        Excel=4
+    }
+
+    public class QAModel
+    {
+        public string ChatModelId { get; set; }
+        public string Context { get; set; }
     }
 }

src/AntSK.Domain/Domain/Model/PageList.cs

@@ -1,4 +1,4 @@
-namespace AntSK.Domain.Model
+namespace AntSK.Domain.Domain.Model
 {
     public class PageList<T>
     {

src/AntSK.Domain/Domain/Model/hfmirror/HfModel.cs

@@ -4,7 +4,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace AntSK.Domain.Model.hfmirror
+namespace AntSK.Domain.Domain.Model.hfmirror
 {
     public class HfModel
     {
@@ -18,7 +18,7 @@ namespace AntSK.Domain.Model.hfmirror
         public string Author { get; set; }
         public HfAuthorData AuthorData { get; set; }
         public int Downloads { get; set; }
-        public bool Gated { get; set; }
+        public object Gated { get; set; }
         public string Id { get; set; }
         public DateTime LastModified { get; set; }
         public int Likes { get; set; }

src/AntSK.Domain/Domain/Model/hfmirror/HfModelDetail.cs

@@ -4,7 +4,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace AntSK.Domain.Model.hfmirror
+namespace AntSK.Domain.Domain.Model.hfmirror
 {
     public class HfModelDetail
     {

src/AntSK.Domain/Domain/Other/BackGroundTaskHandler.cs

@@ -1,27 +1,31 @@
-using AntSK.BackgroundTask;
+using Amazon.Runtime.Internal.Util;
+using AntSK.BackgroundTask;
 using AntSK.Domain.Domain.Interface;
-using AntSK.Domain.Model;
+using AntSK.Domain.Domain.Model;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 
 namespace AntSK.Domain.Domain.Other
 {
     public class BackGroundTaskHandler : IBackgroundTaskHandler<ImportKMSTaskReq>
     {
         private readonly IServiceScopeFactory _scopeFactory;
+        private readonly ILogger<BackGroundTaskHandler> _logger;
 
-        public BackGroundTaskHandler(IServiceScopeFactory scopeFactory)
+        public BackGroundTaskHandler(IServiceScopeFactory scopeFactory, ILogger<BackGroundTaskHandler> logger)
         {
             _scopeFactory = scopeFactory;
+            _logger = logger;
         }
         public async Task ExecuteAsync(ImportKMSTaskReq item)
         {
             using (var scope = _scopeFactory.CreateScope())
             {
-                Console.WriteLine("ExecuteAsync.开始执行后台任务");
+                _logger.LogInformation("ExecuteAsync.开始执行后台任务");
                 var importKMSService = scope.ServiceProvider.GetRequiredService<IImportKMSService>();
                 //不能使用异步
                 importKMSService.ImportKMSTask(item);
-                Console.WriteLine("ExecuteAsync.后台任务执行完成");
+                _logger.LogInformation("ExecuteAsync.后台任务执行完成");
             }
 
         }

src/AntSK.Domain/Domain/Other/Bge/BegRerankConfig.cs

@@ -0,0 +1,78 @@
+using Newtonsoft.Json;
+using Python.Runtime;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static Python.Runtime.Py;
+using AntSK.Domain.Utils;
+
+namespace AntSK.Domain.Domain.Other.Bge
+{
+    public static class BegRerankConfig
+    {
+        public static dynamic model { get; set; }
+
+        static object lockobj = new object();
+
+
+
+        /// <summary>
+        /// 模型写死
+        /// </summary>
+        public static dynamic LoadModel(string pythondllPath, string modelName)
+        {
+            lock (lockobj)
+            {
+                if (model == null)
+                {
+                    PyRunTime.InitRunTime(pythondllPath);
+                    try
+                    {
+                        using (GIL())// 初始化Python环境的Global Interpreter Lock)
+                        {
+                            dynamic modelscope = Py.Import("modelscope");
+                            dynamic flagEmbedding = Py.Import("FlagEmbedding");
+
+                            dynamic model_dir = modelscope.snapshot_download(modelName, revision: "master");
+                            dynamic flagReranker = flagEmbedding.FlagReranker(model_dir, use_fp16: false);
+                            model = flagReranker;
+                            return model;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        throw ex;
+                    }
+                }
+                else
+                {
+                    return model;
+                }
+            }
+        }
+
+
+        public static double Rerank(List<string> list)
+        {
+            using (GIL())
+            {
+                try
+                {
+                    PyList pyList = new PyList();
+                    foreach (string item in list)
+                    {
+                        pyList.Append(item.ToPython()); // 将C# string转换为Python对象并添加到PyList中
+                    }
+                    PyObject result = model.compute_score(pyList, normalize: true);
+                    return result.ConvertToString().Trim('[').Trim(']').ConvertToDouble();
+                }
+                catch (Exception ex)
+                {
+                    throw ex;
+                }
+            }
+        }
+    }
+}

src/AntSK.Domain/Domain/Other/Bge/BgeEmbeddingConfig.cs

@@ -0,0 +1,92 @@
+using Microsoft.KernelMemory.AI.OpenAI;
+using Python.Runtime;
+using Serilog;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static Python.Runtime.Py;
+
+namespace AntSK.Domain.Domain.Other.Bge
+{
+    public static class BgeEmbeddingConfig
+    {
+        public static dynamic model { get; set; }
+
+        static object lockobj = new object();
+
+
+
+        /// <summary>
+        /// 模型写死
+        /// </summary>
+        public static dynamic LoadModel(string pythondllPath, string modelName)
+        {
+            lock (lockobj)
+            {
+                if (model == null)
+                {
+                    PyRunTime.InitRunTime(pythondllPath);
+                    try
+                    {
+                        using (GIL())// 初始化Python环境的Global Interpreter Lock)
+                        {
+                            dynamic modelscope = Import("modelscope");
+                            //dynamic model_dir = modelscope.snapshot_download("AI-ModelScope/bge-large-zh-v1.5", revision: "master");
+                            dynamic model_dir = modelscope.snapshot_download(modelName, revision: "master");
+                            dynamic HuggingFaceBgeEmbeddingstemp = Import("langchain_community.embeddings.huggingface");
+                            dynamic HuggingFaceBgeEmbeddings = HuggingFaceBgeEmbeddingstemp.HuggingFaceBgeEmbeddings;
+                            string model_name = model_dir;
+                            dynamic model_kwargs = new PyDict();
+                            model_kwargs["device"] = new PyString("cpu");
+                            dynamic hugginmodel = HuggingFaceBgeEmbeddings(
+                                  model_name: model_dir,
+                                  model_kwargs: model_kwargs
+                              );
+                            model = hugginmodel;
+                            return hugginmodel;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        throw ex;
+                    }
+                }
+                else
+                    return model;
+            }
+        }
+
+        public static Task<float[]> GetEmbedding(string queryStr)
+        {
+            using (GIL())
+            {
+                PyObject queryResult = model.embed_query(queryStr);
+                var floatList = queryResult.As<float[]>();
+                return Task.FromResult(floatList); ;
+            }
+        }
+
+        public static int TokenCount(string queryStr)
+        {
+            //using (Py.GIL())
+            //{
+            //    PyObject queryResult = model.client.tokenize(queryStr);
+            //    // 使用Python的内置len()函数获取长度
+            //    PyObject lenFunc = Py.Import("builtins").GetAttr("len");
+            //    PyObject length = lenFunc.Invoke(queryResult["input_ids"]);
+            //    int len = length.As<int>(); // 将PyObject转换为C#中的整数
+            //    return len;
+
+            //}
+            var tokenCount1 = DefaultGPTTokenizer.StaticCountTokens(queryStr);
+            return tokenCount1;
+        }
+
+        public static void Dispose()
+        {
+            Log.Information("python dispose");
+        }
+    }
+}

src/AntSK.Domain/Domain/Other/Bge/PyRunTime.cs

@@ -0,0 +1,28 @@
+using Python.Runtime;
+
+namespace AntSK.Domain.Domain.Other.Bge
+{
+    public static class PyRunTime
+    {
+        static object lockobj = new object();
+
+        static bool isInit = false;
+
+        public static void InitRunTime(string pythonPath)
+        {
+            lock (lockobj)
+            {
+                if (!isInit)
+                {
+                    if (string.IsNullOrEmpty(Runtime.PythonDLL))
+                    {
+                        Runtime.PythonDLL = pythonPath;
+                    }
+                    PythonEngine.Initialize();
+                    PythonEngine.BeginAllowThreads();
+                    isInit = true;
+                }
+            }
+        }
+    }
+}

src/AntSK.Domain/Domain/Other/KMExcelHandler.cs

@@ -0,0 +1,157 @@
+using AntSK.Domain.Domain.Model.Constant;
+using AntSK.Domain.Utils;
+using Microsoft.Extensions.Logging;
+using Microsoft.KernelMemory.AI.OpenAI;
+using Microsoft.KernelMemory.Configuration;
+using Microsoft.KernelMemory.DataFormats.Text;
+using Microsoft.KernelMemory.Diagnostics;
+using Microsoft.KernelMemory.Extensions;
+using Microsoft.KernelMemory.Pipeline;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AntSK.Domain.Domain.Other
+{
+    public class KMExcelHandler: IPipelineStepHandler
+    {
+        private readonly TextPartitioningOptions _options;
+        private readonly IPipelineOrchestrator _orchestrator;
+        private readonly ILogger<KMExcelHandler> _log;
+        private readonly TextChunker.TokenCounter _tokenCounter;
+
+        public KMExcelHandler(
+            string stepName,
+            IPipelineOrchestrator orchestrator,
+             TextPartitioningOptions? options = null,
+            ILogger<KMExcelHandler>? log = null)
+        {
+            this.StepName = stepName;
+            this._orchestrator = orchestrator;
+            this._options = options ?? new TextPartitioningOptions();
+            this._options.Validate();
+
+            this._log = log ?? DefaultLogger<KMExcelHandler>.Instance;
+            this._tokenCounter = DefaultGPTTokenizer.StaticCountTokens;
+        }
+
+        /// <inheritdoc />
+        public string StepName { get; }
+
+        /// <inheritdoc />
+        public async Task<(bool success, DataPipeline updatedPipeline)> InvokeAsync(
+            DataPipeline pipeline, CancellationToken cancellationToken = default)
+        {
+            this._log.LogDebug("Partitioning text, pipeline '{0}/{1}'", pipeline.Index, pipeline.DocumentId);
+
+            if (pipeline.Files.Count == 0)
+            {
+                this._log.LogWarning("Pipeline '{0}/{1}': there are no files to process, moving to next pipeline step.", pipeline.Index, pipeline.DocumentId);
+                return (true, pipeline);
+            }
+
+            foreach (DataPipeline.FileDetails uploadedFile in pipeline.Files)
+            {
+                // Track new files being generated (cannot edit originalFile.GeneratedFiles while looping it)
+                Dictionary<string, DataPipeline.GeneratedFileDetails> newFiles = new();
+
+                foreach (KeyValuePair<string, DataPipeline.GeneratedFileDetails> generatedFile in uploadedFile.GeneratedFiles)
+                {
+                    var file = generatedFile.Value;
+                    if (file.AlreadyProcessedBy(this))
+                    {
+                        this._log.LogTrace("File {0} already processed by this handler", file.Name);
+                        continue;
+                    }
+
+                    // Partition only the original text
+                    if (file.ArtifactType != DataPipeline.ArtifactTypes.ExtractedText)
+                    {
+                        this._log.LogTrace("Skipping file {0} (not original text)", file.Name);
+                        continue;
+                    }
+
+                    // Use a different partitioning strategy depending on the file type
+                    List<string> partitions;
+                    List<string> sentences;
+                    BinaryData partitionContent = await this._orchestrator.ReadFileAsync(pipeline, file.Name, cancellationToken).ConfigureAwait(false);
+
+                    // Skip empty partitions. Also: partitionContent.ToString() throws an exception if there are no bytes.
+                    if (partitionContent.ToArray().Length == 0) { continue; }
+
+                    switch (file.MimeType)
+                    {
+                        case MimeTypes.PlainText:
+                            {
+                                this._log.LogDebug("Partitioning text file {0}", file.Name);
+                                string content = partitionContent.ToString();
+                                var excelList = content.Split(KmsConstantcs.KMExcelSplit, StringSplitOptions.RemoveEmptyEntries).ToList();
+                                sentences = excelList;
+                                partitions = excelList;
+                                break;
+                            }
+
+                        case MimeTypes.MarkDown:
+                            {
+                                this._log.LogDebug("Partitioning text file {0}", file.Name);
+                                string content = partitionContent.ToString();
+                                var excelList = content.Split(KmsConstantcs.KMExcelSplit, StringSplitOptions.RemoveEmptyEntries).ToList();
+                                sentences = excelList;
+                                partitions = excelList;
+                                break;
+                            }
+                        default:
+                            this._log.LogWarning("File {0} cannot be partitioned, type '{1}' not supported", file.Name, file.MimeType);
+                            // Don't partition other files
+                            continue;
+                    }
+
+                    if (partitions.Count == 0) { continue; }
+
+                    this._log.LogDebug("Saving {0} file partitions", partitions.Count);
+                    for (int partitionNumber = 0; partitionNumber < partitions.Count; partitionNumber++)
+                    {
+                        // TODO: turn partitions in objects with more details, e.g. page number
+                        string text = partitions[partitionNumber];
+                        int sectionNumber = 0; // TODO: use this to store the page number (if any)
+                        BinaryData textData = new(text);
+
+                        int tokenCount = this._tokenCounter(text);
+                        this._log.LogDebug("Partition size: {0} tokens", tokenCount);
+
+                        var destFile = uploadedFile.GetPartitionFileName(partitionNumber);
+                        await this._orchestrator.WriteFileAsync(pipeline, destFile, textData, cancellationToken).ConfigureAwait(false);
+
+                        var destFileDetails = new DataPipeline.GeneratedFileDetails
+                        {
+                            Id = Guid.NewGuid().ToString("N"),
+                            ParentId = uploadedFile.Id,
+                            Name = destFile,
+                            Size = text.Length,
+                            MimeType = MimeTypes.PlainText,
+                            ArtifactType = DataPipeline.ArtifactTypes.TextPartition,
+                            PartitionNumber = partitionNumber,
+                            SectionNumber = sectionNumber,
+                            Tags = pipeline.Tags,
+                            ContentSHA256 = textData.AntSKCalculateSHA256(),
+                        };
+                        newFiles.Add(destFile, destFileDetails);
+                        destFileDetails.MarkProcessedBy(this);
+                    }
+
+                    file.MarkProcessedBy(this);
+                }
+
+                // Add new files to pipeline status
+                foreach (var file in newFiles)
+                {
+                    uploadedFile.GeneratedFiles.Add(file.Key, file.Value);
+                }
+            }
+
+            return (true, pipeline);
+        }
+    }
+}

src/AntSK.Domain/Domain/Other/LLamaConfig.cs

@@ -1,44 +0,0 @@
-using LLama;
-using LLama.Common;
-using LLamaSharp.KernelMemory;
-
-namespace AntSK.Domain.Domain.Other
-{
-    public static class LLamaConfig
-    {
-        static object lockobj = new object();
-        /// <summary>
-        /// 避免模型重复加载，本地缓存
-        /// </summary>
-        static Dictionary<string, (LLamaWeights, ModelParams)> dicLLamaWeights = new Dictionary<string, (LLamaWeights, ModelParams)>();
-        public static (LLamaWeights, ModelParams) GetLLamaConfig(string modelPath, LLamaSharpConfig config = null)
-        {
-            lock (lockobj)
-            {
-                if (dicLLamaWeights.ContainsKey(modelPath))
-                {
-                    return dicLLamaWeights.GetValueOrDefault(modelPath);
-                }
-                else
-                {
-                    InferenceParams infParams = new() { AntiPrompts = ["\n\n"] };
-                    LLamaSharpConfig lsConfig = new(modelPath) { DefaultInferenceParams = infParams };
-                    if (config != null)
-                    {
-                        lsConfig = config;
-                    }
-                    var parameters = new ModelParams(lsConfig.ModelPath)
-                    {
-                        ContextSize = lsConfig?.ContextSize ?? 2048,
-                        Seed = lsConfig?.Seed ?? 0,
-                        GpuLayerCount = lsConfig?.GpuLayerCount ?? 10,
-                        EmbeddingMode = true
-                    };
-                    var weights = LLamaWeights.LoadFromFile(parameters);
-                    dicLLamaWeights.Add(modelPath, (weights, parameters));
-                    return (weights, parameters);
-                }
-            }
-        }
-    }
-}

src/AntSK.Domain/Domain/Other/QAHandler.cs

@@ -0,0 +1,173 @@
+using AntSK.Domain.Domain.Interface;
+using AntSK.Domain.Domain.Model;
+using AntSK.Domain.Utils;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Microsoft.KernelMemory.AI.OpenAI;
+using Microsoft.KernelMemory.Configuration;
+using Microsoft.KernelMemory.DataFormats.Text;
+using Microsoft.KernelMemory.Diagnostics;
+using Microsoft.KernelMemory.Extensions;
+using Microsoft.KernelMemory.Pipeline;
+using Microsoft.SemanticKernel;
+using Newtonsoft.Json;
+using RestSharp;
+using System.Security.Policy;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace AntSK.Domain.Domain.Other
+{
+    public class QAHandler : IPipelineStepHandler
+    {
+        private readonly TextPartitioningOptions _options;
+        private readonly IPipelineOrchestrator _orchestrator;
+        private readonly ILogger<QAHandler> _log;
+        private readonly TextChunker.TokenCounter _tokenCounter;
+        private readonly IKernelService _kernelService;
+        public QAHandler(
+            string stepName,
+            IPipelineOrchestrator orchestrator,
+            IKernelService kernelService,
+            TextPartitioningOptions? options = null,
+            ILogger<QAHandler>? log = null
+            )
+        {
+            this.StepName = stepName;
+            this._orchestrator = orchestrator;
+            this._options = options ?? new TextPartitioningOptions();
+            this._options.Validate();
+
+            this._log = log ?? DefaultLogger<QAHandler>.Instance;
+            this._tokenCounter = DefaultGPTTokenizer.StaticCountTokens;
+            this._kernelService = kernelService;
+        }
+
+        /// <inheritdoc />
+        public string StepName { get; }
+
+        /// <inheritdoc />
+        public async Task<(bool success, DataPipeline updatedPipeline)> InvokeAsync(
+            DataPipeline pipeline, CancellationToken cancellationToken = default)
+        {
+            this._log.LogDebug("Partitioning text, pipeline '{0}/{1}'", pipeline.Index, pipeline.DocumentId);
+
+            if (pipeline.Files.Count == 0)
+            {
+                this._log.LogWarning("Pipeline '{0}/{1}': there are no files to process, moving to next pipeline step.", pipeline.Index, pipeline.DocumentId);
+                return (true, pipeline);
+            }
+
+            foreach (DataPipeline.FileDetails uploadedFile in pipeline.Files)
+            {
+                // Track new files being generated (cannot edit originalFile.GeneratedFiles while looping it)
+                Dictionary<string, DataPipeline.GeneratedFileDetails> newFiles = new();
+
+                foreach (KeyValuePair<string, DataPipeline.GeneratedFileDetails> generatedFile in uploadedFile.GeneratedFiles)
+                {
+                    var file = generatedFile.Value;
+                    if (file.AlreadyProcessedBy(this))
+                    {
+                        this._log.LogTrace("File {0} already processed by this handler", file.Name);
+                        continue;
+                    }
+
+                    // Partition only the original text
+                    if (file.ArtifactType != DataPipeline.ArtifactTypes.ExtractedText)
+                    {
+                        this._log.LogTrace("Skipping file {0} (not original text)", file.Name);
+                        continue;
+                    }
+
+                    // Use a different partitioning strategy depending on the file type
+                    List<string> partitions;
+                    List<string> sentences;
+                    BinaryData partitionContent = await this._orchestrator.ReadFileAsync(pipeline, file.Name, cancellationToken).ConfigureAwait(false);
+
+                    // Skip empty partitions. Also: partitionContent.ToString() throws an exception if there are no bytes.
+                    if (partitionContent.ToArray().Length == 0) { continue; }
+
+                    switch (file.MimeType)
+                    {
+                        case MimeTypes.PlainText:
+                        case MimeTypes.MarkDown:
+                            {   
+                                this._log.LogDebug("Partitioning text file {0}", file.Name);
+                                string content = partitionContent.ToString();
+
+                                var kernel = _kernelService.GetKernelByAIModelID(StepName);
+                                var lines = TextChunker.SplitPlainTextLines(content, 299);
+                                var paragraphs = TextChunker.SplitPlainTextParagraphs(lines, 3000);
+                                KernelFunction jsonFun = kernel.Plugins.GetFunction("KMSPlugin", "QA");
+
+                                List<string> qaList = new List<string>();
+                                foreach (var para in paragraphs)
+                                {
+                                    var qaresult = await kernel.InvokeAsync(function: jsonFun, new KernelArguments() { ["input"] = para });
+                                    var qaListStr = qaresult.GetValue<string>().ConvertToString();
+
+                                    string pattern = @"Q\d+:.*?A\d+:.*?(?=(Q\d+:|$))";
+                                    RegexOptions options = RegexOptions.Singleline;
+
+                                    foreach (Match match in Regex.Matches(qaListStr, pattern, options))
+                                    {
+                                        qaList.Add(match.Value.Trim()); // Trim用于删除可能的首尾空格
+                                    }
+                                }
+                                sentences = qaList;
+                                partitions = qaList;        
+                                break;
+                            }
+                        default:
+                            this._log.LogWarning("File {0} cannot be partitioned, type '{1}' not supported", file.Name, file.MimeType);
+                            // Don't partition other files
+                            continue;
+                    }
+
+                    if (partitions.Count == 0) { continue; }
+
+                    this._log.LogDebug("Saving {0} file partitions", partitions.Count);
+                    for (int partitionNumber = 0; partitionNumber < partitions.Count; partitionNumber++)
+                    {
+                        // TODO: turn partitions in objects with more details, e.g. page number
+                        string text = partitions[partitionNumber];
+                        int sectionNumber = 0; // TODO: use this to store the page number (if any)
+                        BinaryData textData = new(text);
+
+                        int tokenCount = this._tokenCounter(text);
+                        this._log.LogDebug("Partition size: {0} tokens", tokenCount);
+
+                        var destFile = uploadedFile.GetPartitionFileName(partitionNumber);
+                        await this._orchestrator.WriteFileAsync(pipeline, destFile, textData, cancellationToken).ConfigureAwait(false);
+
+                        var destFileDetails = new DataPipeline.GeneratedFileDetails
+                        {
+                            Id = Guid.NewGuid().ToString("N"),
+                            ParentId = uploadedFile.Id,
+                            Name = destFile,
+                            Size = text.Length,
+                            MimeType = MimeTypes.PlainText,
+                            ArtifactType = DataPipeline.ArtifactTypes.TextPartition,
+                            PartitionNumber = partitionNumber,
+                            SectionNumber = sectionNumber,
+                            Tags = pipeline.Tags,
+                            ContentSHA256 = textData.AntSKCalculateSHA256(),
+                        };
+                        newFiles.Add(destFile, destFileDetails);
+                        destFileDetails.MarkProcessedBy(this);
+                    }
+
+                    file.MarkProcessedBy(this);
+                }
+
+                // Add new files to pipeline status
+                foreach (var file in newFiles)
+                {
+                    uploadedFile.GeneratedFiles.Add(file.Key, file.Value);
+                }
+            }
+
+            return (true, pipeline);
+        }
+    }
+}

src/AntSK.Domain/Domain/Service/ChatService.cs

@@ -1,18 +1,23 @@
 using AntSK.Domain.Common.DependencyInjection;
 using AntSK.Domain.Domain.Interface;
+using AntSK.Domain.Domain.Model;
+using AntSK.Domain.Domain.Model.Constant;
+using AntSK.Domain.Domain.Model.Dto;
+using AntSK.Domain.Domain.Other.Bge;
 using AntSK.Domain.Repositories;
-using Microsoft.SemanticKernel.Connectors.OpenAI;
-using Microsoft.SemanticKernel;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using AntSK.Domain.Utils;
-using Microsoft.KernelMemory;
-using AntSK.Domain.Model;
-using AntSK.Domain.Domain.Dto;
+using AntSK.LLM.StableDiffusion;
 using Markdig;
+using Microsoft.KernelMemory;
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.ChatCompletion;
+using Microsoft.SemanticKernel.Connectors.OpenAI;
+using System.Diagnostics;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Text.RegularExpressions;
+using ChatHistory = Microsoft.SemanticKernel.ChatCompletion.ChatHistory;
 
 namespace AntSK.Domain.Domain.Service
 {
@@ -20,7 +25,8 @@ namespace AntSK.Domain.Domain.Service
     public class ChatService(
         IKernelService _kernelService,
         IKMService _kMService,
-        IKmsDetails_Repositories _kmsDetails_Repositories
+        IKmsDetails_Repositories _kmsDetails_Repositories,
+        IAIModels_Repositories _aIModels_Repositories
         ) : IChatService
     {
         /// <summary>
@@ -30,73 +36,312 @@ namespace AntSK.Domain.Domain.Service
         /// <param name="questions"></param>
         /// <param name="history"></param>
         /// <returns></returns>
-        public async IAsyncEnumerable<StreamingKernelContent> SendChatByAppAsync(Apps app, string questions, string history)
+        public async IAsyncEnumerable<string> SendChatByAppAsync(Apps app, ChatHistory history)
         {
-            if (string.IsNullOrEmpty(app.Prompt) || !app.Prompt.Contains("{{$input}}"))
-            {
-                //如果模板为空，给默认提示词
-                app.Prompt = app.Prompt.ConvertToString() + "{{$input}}";
-            }
             var _kernel = _kernelService.GetKernelByApp(app);
+            var chat = _kernel.GetRequiredService<IChatCompletionService>();
             var temperature = app.Temperature / 100;//存的是0~100需要缩小
             OpenAIPromptExecutionSettings settings = new() { Temperature = temperature };
-            if (!string.IsNullOrEmpty(app.ApiFunctionList)|| !string.IsNullOrEmpty(app.NativeFunctionList))//这里还需要加上本地插件的
+            List<string> completionList = new List<string>();
+            if (!string.IsNullOrEmpty(app.ApiFunctionList) || !string.IsNullOrEmpty(app.NativeFunctionList))//这里还需要加上本地插件的
             {
                 _kernelService.ImportFunctionsByApp(app, _kernel);
-                settings.ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions;
+                settings.ToolCallBehavior = ToolCallBehavior.EnableKernelFunctions;
+                while (true)
+                {
+                    ChatMessageContent result = await chat.GetChatMessageContentAsync(history, settings, _kernel);
+                    if (result.Content is not null)
+                    {
+                        string chunkCompletion = result.Content.ConvertToString();
+                        completionList.Add(chunkCompletion);
+                        foreach (var content in completionList)
+                        {
+                            yield return content.ConvertToString();
+                        }
+                        break;
+                    }
+
+                    history.Add(result);
+
+                    IEnumerable<FunctionCallContent> functionCalls = FunctionCallContent.GetFunctionCalls(result);
+                    if (!functionCalls.Any())
+                    {
+                        break;
+                    }
+
+                    foreach (var functionCall in functionCalls)
+                    {
+                        FunctionResultContent resultContent = await functionCall.InvokeAsync(_kernel);
+
+                        history.Add(resultContent.ToChatMessage());
+                    }
+                }
             }
-            var func = _kernel.CreateFunctionFromPrompt(app.Prompt, settings);
-            var chatResult = _kernel.InvokeStreamingAsync(function: func, arguments: new KernelArguments() { ["input"] = $"{history}{Environment.NewLine} user:{questions}" });
-            await foreach (var content in chatResult)
+            else
             {
-                yield return content;
+                var chatResult = chat.GetStreamingChatMessageContentsAsync(history, settings, _kernel);
+                await foreach (var content in chatResult)
+                {
+                    yield return content.ConvertToString();
+                }
             }
         }
 
-        public async IAsyncEnumerable<StreamingKernelContent> SendKmsByAppAsync(Apps app, string questions, string history, List<RelevantSource> relevantSources = null)
+        public async IAsyncEnumerable<StreamingKernelContent> SendKmsByAppAsync(Apps app, string questions, ChatHistory history, string filePath, List<RelevantSource> relevantSources = null)
         {
+            relevantSources?.Clear();
+            var relevantSourceList = await _kMService.GetRelevantSourceList(app, questions);
             var _kernel = _kernelService.GetKernelByApp(app);
-            //知识库问答
-            var filters = new List<MemoryFilter>();
-            var kmsidList = app.KmsIdList.Split(",");
-            //只取第一个知识库的配置
-            var _memory = _kMService.GetMemoryByKMS(kmsidList.FirstOrDefault());
-            foreach (var kmsid in kmsidList)
+            if (!string.IsNullOrWhiteSpace(filePath))
             {
-                filters.Add(new MemoryFilter().ByTag("kmsid", kmsid));
-            }
-            var xlresult = await _memory.SearchAsync(questions, index: "kms", filters: filters);
-            string dataMsg = "";
-            if (xlresult != null)
-            {
-                foreach (var item in xlresult.Results)
-                {
-                    foreach (var part in item.Partitions)
-                    {
-                        dataMsg += $"[file:{item.SourceName};Relevance:{(part.Relevance * 100).ToString("F2")}%]:{part.Text}{Environment.NewLine}";
+                var memory = _kMService.GetMemoryByApp(app);
 
-                        if (relevantSources.IsNotNull())
+                // 匹配GUID的正则表达式
+                string pattern = @"\b[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\b";
+
+                // 使用正则表达式找到匹配
+                Match match = Regex.Match(filePath, pattern);
+                if (match.Success)
+                {
+                    var fileId = match.Value;
+
+                    var status=await  memory.IsDocumentReadyAsync(fileId, index: KmsConstantcs.KmsIndex);
+                    if (!status)
+                    {
+                        var result = await memory.ImportDocumentAsync(new Document(fileId).AddFile(filePath)
+                                  .AddTag(KmsConstantcs.AppIdTag, app.Id)
+                                  .AddTag(KmsConstantcs.FileIdTag, fileId)
+                                  , index: KmsConstantcs.FileIndex);
+                    }
+
+                    var filters = new List<MemoryFilter>() {
+                        new MemoryFilter().ByTag(KmsConstantcs.AppIdTag, app.Id),
+                        new MemoryFilter().ByTag(KmsConstantcs.FileIdTag, fileId)
+                    };
+
+                    var searchResult = await memory.SearchAsync(questions, index: KmsConstantcs.FileIndex, filters: filters);
+                    relevantSourceList.AddRange(searchResult.Results.SelectMany(item => item.Partitions.Select(part => new RelevantSource()
+                    {
+                        SourceName = item.SourceName,
+                        Text = Markdown.ToHtml(part.Text),
+                        Relevance = part.Relevance
+                    })));
+                    app.Prompt = KmsConstantcs.KmsPrompt;
+                }
+            }
+
+
+            var dataMsg = new StringBuilder();
+            if (relevantSourceList.Any())
+            {
+                if (!string.IsNullOrEmpty(app.RerankModelID))
+                {
+                    var rerankModel=_aIModels_Repositories.GetById(app.RerankModelID);
+                    BegRerankConfig.LoadModel(rerankModel.EndPoint, rerankModel.ModelName);
+                    //进行rerank
+                    foreach (var item in relevantSourceList)
+                    {
+                        List<string> rerank = new List<string>();
+                        rerank.Add(questions);
+                        rerank.Add(item.Text);
+                        item.RerankScore = BegRerankConfig.Rerank(rerank);
+                      
+                    }
+                    relevantSourceList = relevantSourceList.OrderByDescending(p => p.RerankScore).Take(app.MaxMatchesCount).ToList();
+                }
+                    
+                bool isSearch = false;
+                foreach (var item in relevantSourceList)
+                {
+                    if (!string.IsNullOrEmpty(app.RerankModelID))
+                    {
+                        //匹配重排后相似度
+                        if (item.RerankScore >= app.Relevance / 100)
                         {
-                            string sourceName = item.SourceName;
-                            var fileDetail = _kmsDetails_Repositories.GetFirst(p => p.FileGuidName == item.SourceName);
-                            if (fileDetail.IsNotNull())
-                            {
-                                sourceName = fileDetail.FileName;
-                            }
-                            relevantSources.Add(new RelevantSource() { SourceName = sourceName, Text = Markdown.ToHtml(part.Text), Relevance = part.Relevance });
+                            dataMsg.AppendLine(item.ToString());
+                            isSearch = true;
+                        }
+                    }
+                    else 
+                    {
+                        //匹配相似度
+                        if (item.Relevance >= app.Relevance / 100)
+                        {
+                            dataMsg.AppendLine(item.ToString());
+                            isSearch = true;
                         }
                     }
                 }
-                KernelFunction jsonFun = _kernel.Plugins.GetFunction("KMSPlugin", "Ask");
-                var chatResult = _kernel.InvokeStreamingAsync(function: jsonFun,
-                    arguments: new KernelArguments() { ["doc"] = dataMsg, ["history"] = history, ["questions"] = questions });
 
-                MessageInfo info = null;
-                await foreach (var content in chatResult)
+                //处理markdown显示
+                relevantSources?.AddRange(relevantSourceList);
+                Dictionary<string, string> fileDic = new Dictionary<string, string>();
+                foreach (var item in relevantSourceList)
                 {
-                    yield return content;
+                    if (fileDic.ContainsKey(item.SourceName))
+                    {
+                        item.SourceName = fileDic[item.SourceName];
+                    }
+                    else
+                    {
+                        var fileDetail = _kmsDetails_Repositories.GetFirst(p => p.FileGuidName == item.SourceName);
+                        if (fileDetail.IsNotNull())
+                        {
+                            string fileName = fileDetail.FileName;
+                            fileDic.Add(item.SourceName, fileName);
+                            item.SourceName = fileName;
+                        }       
+                    }
+                    item.Text = Markdown.ToHtml(item.Text);
+                }
+
+                if (isSearch)
+                {
+                    //KernelFunction jsonFun = _kernel.Plugins.GetFunction("KMSPlugin", "Ask1");
+                    var temperature = app.Temperature / 100;//存的是0~100需要缩小
+                    OpenAIPromptExecutionSettings settings = new() { Temperature = temperature };
+                    var func = _kernel.CreateFunctionFromPrompt(app.Prompt , settings);
+
+                    var chatResult = _kernel.InvokeStreamingAsync(function: func,
+                        arguments: new KernelArguments() { ["doc"] = dataMsg.ToString(), ["history"] = string.Join("\n", history.Select(x => x.Role + ": " + x.Content)), ["input"] = questions });
+
+                    await foreach (var content in chatResult)
+                    {
+                        yield return content;
+                    }
+                }
+                else
+                {
+                    yield return new StreamingTextContent(KmsConstantcs.KmsSearchNull);
                 }
             }
+            else
+            {
+                yield return new StreamingTextContent(KmsConstantcs.KmsSearchNull);
+            }
+        }
+
+
+        public async Task<string> SendImgByAppAsync(Apps app, string questions)
+        {
+            var imageModel = _aIModels_Repositories.GetFirst(p => p.Id == app.ImageModelID);
+            KernelArguments args = new() {
+                { "input", questions }
+            };
+            var _kernel = _kernelService.GetKernelByApp(app);
+            var temperature = app.Temperature / 100; //存的是0~100需要缩小
+            OpenAIPromptExecutionSettings settings = new() { Temperature = temperature };
+            var func = _kernel.CreateFunctionFromPrompt("Translate this into English:{{$input}}", settings);
+            var chatResult = await _kernel.InvokeAsync(function: func, arguments: args);
+            if (chatResult.IsNotNull())
+            {
+                //Can Load stable-diffusion library in diffenert environment
+
+                //SDHelper.LoadLibrary()
+                string versionString = string.Empty;
+                string extensionString = string.Empty;
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    extensionString = ".dll";
+                }
+                else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                {
+                    extensionString = ".so";
+                }
+                else
+                {
+                    throw new InvalidOperationException("OS Platform no support");
+                }
+
+                ProcessStartInfo startInfo = new ProcessStartInfo("nvcc", "--version");
+                startInfo.RedirectStandardOutput = true;
+                startInfo.UseShellExecute = false;
+                startInfo.CreateNoWindow = true;
+                using (Process process = Process.Start(startInfo))
+                {
+                    if (process != null)
+                    {
+                        string result = process.StandardOutput.ReadToEnd();
+                        Regex regex = new Regex(@"release (\d+).[\d]");
+                        Match match = regex.Match(result);
+                        if (match.Success)
+                        {
+                            switch (match.Groups[1].Value.ToString())
+                            {
+                                case "11":
+                                    versionString = "Cuda11";
+                                    break;
+                                case "12":
+                                    versionString = "Cuda12";
+                                    break;
+                                default:
+                                    versionString = "CPU";
+                                    break;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        throw new Exception("nvcc get an error");
+                    }
+                }
+
+                string libraryPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "StableDiffusion", "Backend", versionString, "stable-diffusion" + extensionString);
+                NativeLibrary.TryLoad(libraryPath, out _);
+                string prompt = chatResult.GetValue<string>();
+                if (!SDHelper.IsInitialized)
+                {
+                    Structs.ModelParams modelParams = new Structs.ModelParams
+                    {
+                        ModelPath = imageModel.ModelName,
+                        RngType = Structs.RngType.CUDA_RNG,
+                        //VaePath = vaePath,
+                        //KeepVaeOnCpu = keepVaeOnCpu,
+                        //set false can get a better image, otherwise can use lower vram
+                        VaeTiling = false,
+                        //LoraModelDir = loraModelDir,
+                    };
+                    bool result = SDHelper.Initialize(modelParams);
+                }
+
+                Structs.TextToImageParams textToImageParams = new Structs.TextToImageParams
+                {
+                    Prompt = prompt,
+                    NegativePrompt = "bad quality, wrong image, worst quality",
+                    SampleMethod = (Structs.SampleMethod)Enum.Parse(typeof(Structs.SampleMethod), "EULER_A"),
+                    //the base image size in SD1.5 is 512x512
+                    Width = 512,
+                    Height = 512,
+                    NormalizeInput = true,
+                    ClipSkip = -1,
+                    CfgScale = 7,
+                    SampleSteps = 20,
+                    Seed = -1,
+                };
+                Bitmap[] outputImages = SDHelper.TextToImage(textToImageParams);
+                var base64 = ImageUtils.BitmapToBase64(outputImages[0]);
+                return base64;
+            }
+            else
+            {
+                return "";
+            }
+        }
+
+        public async Task<ChatHistory> GetChatHistory(List<Chats> MessageList, ChatHistory history)
+        {
+            foreach (var item in MessageList)
+            {
+                if (item.IsSend)
+                {
+                    history.AddUserMessage(item.Context);
+                }
+                else
+                {
+                    history.AddAssistantMessage(item.Context);
+                }
+            }
+            return history;
         }
     }
-}
+}

src/AntSK.Domain/Domain/Service/FunctionService.cs

@@ -1,17 +1,25 @@
-using System.Reflection;
+using System.ComponentModel;
+using System.Reflection;
+using System.Runtime.Loader;
 using System.Xml;
 using AntSK.Domain.Common;
 using AntSK.Domain.Utils;
+using System.Text.RegularExpressions;
+using Microsoft.SemanticKernel;
+using HtmlAgilityPack;
+using System.Collections.Generic;
+using Serilog;
 
 namespace AntSK.Domain.Domain.Service
 {
     public class FunctionService
     {
-        private readonly Dictionary<string, Func<object[], object>> _methodCache;
+        private readonly Dictionary<string, MethodInfo> _methodCache;
         private readonly Dictionary<string, (string Description, (Type ParameterType, string Description) ReturnType, (string ParameterName, Type ParameterType, string Description)[] Parameters)> _methodInfos;
 
         private readonly IServiceProvider _serviceProvider;
-        private readonly Assembly[] _assemblies;
+        private Assembly[] _assemblies;
+        private readonly AssemblyLoadContext loadContext;
 
         public FunctionService(IServiceProvider serviceProvider, Assembly[] assemblies)
         {
@@ -19,9 +27,10 @@ namespace AntSK.Domain.Domain.Service
             _methodInfos = [];
             _serviceProvider = serviceProvider;
             _assemblies = assemblies;
+            loadContext = new AssemblyLoadContext("AntSKLoadContext", true);
         }
 
-        public Dictionary<string, Func<object[], object>> Functions => _methodCache;
+        public Dictionary<string, MethodInfo> Functions => _methodCache;
         public Dictionary<string, (string Description, (Type ParameterType, string Description) ReturnType, (string ParameterName, Type ParameterType, string Description)[] Parameters)> MethodInfos => _methodInfos;
 
         /// <summary>
@@ -39,7 +48,26 @@ namespace AntSK.Domain.Domain.Service
                 // 从缓存中获取标记了ActionAttribute的方法
                 foreach (var type in assembly.GetTypes())
                 {
-                    markedMethods.AddRange(type.GetMethods().Where(m => m.GetCustomAttributes(typeof(AntSkFunctionAttribute), true).Length > 0));
+                    markedMethods.AddRange(type.GetMethods().Where(m =>
+                    {
+                        DescriptionAttribute da = (DescriptionAttribute)m.GetCustomAttributes(typeof(DescriptionAttribute), true).FirstOrDefault();
+                        return da != null && da.Description.Contains( "AntSK");
+                    }));
+                }
+            }
+
+            //动态加载部分
+            var loadedAssemblies = loadContext.Assemblies.ToList();
+            foreach (var assembly in loadedAssemblies)
+            {
+                // 从缓存中获取标记了ActionAttribute的方法
+                foreach (var type in assembly.GetTypes())
+                {
+                    markedMethods.AddRange(type.GetMethods().Where(m =>
+                    {
+                        DescriptionAttribute da = (DescriptionAttribute)m.GetCustomAttributes(typeof(DescriptionAttribute), true).FirstOrDefault();
+                        return da != null && da.Description.Contains("AntSK");
+                    }));
                 }
             }
 
@@ -47,23 +75,49 @@ namespace AntSK.Domain.Domain.Service
             foreach (var method in markedMethods)
             {
                 var key = $"{method.DeclaringType.Assembly.GetName().Name}_{method.DeclaringType.Name}_{method.Name}";
-                _methodCache.TryAdd(key, arguments =>
-                {
-                    var instance = _serviceProvider.GetService(method.DeclaringType);
-                    return method.Invoke(instance, arguments);
-                });
-
-                var xmlCommentHelper = new XmlCommentHelper();
-                xmlCommentHelper.LoadAll();
-
-                var description = xmlCommentHelper.GetMethodComment(method);
-                var dict = xmlCommentHelper.GetParameterComments(method);
-
-                var parameters = method.GetParameters().Select(x => (x.Name, x.ParameterType, dict[x.Name])).ToArray();
-                var returnType = xmlCommentHelper.GetMethodReturnComment(method);
+                string pattern = "[^a-zA-Z0-9_]";
+                // 使用 '-' 替换非ASCII的正则表达式的字符
+                key = Regex.Replace(key, pattern, "_");
+                _methodCache.TryAdd(key, method);
 
+                var description= method.GetCustomAttribute<DescriptionAttribute>().Description.ConvertToString().Replace("AntSK:","");
+                var returnType = method.ReturnParameter.GetCustomAttribute<DescriptionAttribute>().Description.ConvertToString();
+                var parameters = method.GetParameters().Select(x => (x.Name, x.ParameterType,x.GetCustomAttribute<DescriptionAttribute>()?.Description)).ToArray();
+                // 假设 _methodInfos 是一个已经定义好的字典，用来保存方法的相关信息
                 _methodInfos.TryAdd(key, (description, (method.ReflectedType, returnType), parameters));
             }
         }
+
+
+        public void FuncLoad(string pluginPath)
+        {
+            try
+            {
+                if (File.Exists(pluginPath))
+                {
+                    string directory = Path.GetDirectoryName(pluginPath);
+                    string fileName = Path.GetFileName(pluginPath);
+                    var resolver = new AssemblyDependencyResolver(directory);
+
+                    // Create a custom AssemblyLoadContext
+
+                    loadContext.Resolving += (context, assemblyName) =>
+                    {
+                        string assemblyPath = resolver.ResolveAssemblyToPath(assemblyName);
+                        if (assemblyPath != null)
+                        {
+                            return context.LoadFromAssemblyPath(assemblyPath);
+                        }
+                        return null;
+                    };
+                    // Load your assembly
+                    Assembly pluginAssembly = loadContext.LoadFromAssemblyPath(pluginPath);
+                }
+            }
+            catch (Exception ex)
+            {
+               Log.Error(ex.Message + " ---- " + ex.StackTrace);
+            }
+        }    
     }
 }

src/AntSK.Domain/Domain/Service/ImportKMSService.cs

@@ -1,8 +1,14 @@
 using AntSK.Domain.Common.DependencyInjection;
 using AntSK.Domain.Domain.Interface;
-using AntSK.Domain.Model;
+using AntSK.Domain.Domain.Model;
+using AntSK.Domain.Domain.Model.Constant;
+using AntSK.Domain.Domain.Model.Excel;
+using AntSK.Domain.Domain.Other;
 using AntSK.Domain.Repositories;
+using Microsoft.Extensions.Logging;
 using Microsoft.KernelMemory;
+using Microsoft.KernelMemory.Handlers;
+using System.Text;
 
 namespace AntSK.Domain.Domain.Service
 {
@@ -10,7 +16,8 @@ namespace AntSK.Domain.Domain.Service
     public class ImportKMSService(
         IKMService _kMService,
         IKmsDetails_Repositories _kmsDetails_Repositories,
-        IKmss_Repositories _kmss_Repositories
+        IKmss_Repositories _kmss_Repositories,
+        ILogger<ImportKMSService> _logger
         ) : IImportKMSService
     {
 
@@ -19,18 +26,40 @@ namespace AntSK.Domain.Domain.Service
             try
             {
                 var km = _kmss_Repositories.GetFirst(p => p.Id == req.KmsId);
-
                 var _memory = _kMService.GetMemoryByKMS(km.Id);
                 string fileid = req.KmsDetail.Id;
+                List<string> step = new List<string>();
+                if (req.IsQA)
+                {
+                    _memory.Orchestrator.AddHandler<TextExtractionHandler>("extract_text");
+                    _memory.Orchestrator.AddHandler<QAHandler>(km.ChatModelID);
+                    _memory.Orchestrator.AddHandler<GenerateEmbeddingsHandler>("generate_embeddings");
+                    _memory.Orchestrator.AddHandler<SaveRecordsHandler>("save_memory_records");
+                    step.Add("extract_text");
+                    step.Add(km.ChatModelID);
+                    step.Add("generate_embeddings");
+                    step.Add("save_memory_records");
+                }
+
                 switch (req.ImportType)
                 {
                     case ImportType.File:
-                        //导入文件
                         {
-                            var importResult = _memory.ImportDocumentAsync(new Document(fileid)
-                          .AddFile(req.FilePath)
-                          .AddTag("kmsid", req.KmsId)
-                          , index: "kms").Result;
+                            //导入文件
+                            if (req.IsQA)
+                            {
+                                var importResult = _memory.ImportDocumentAsync(new Document(fileid)
+                                .AddFile(req.FilePath)
+                                .AddTag(KmsConstantcs.KmsIdTag, req.KmsId)
+                                ,index: KmsConstantcs.KmsIndex ,steps: step.ToArray()).Result;
+                            }
+                            else 
+                            {
+                                var importResult = _memory.ImportDocumentAsync(new Document(fileid)
+                                 .AddFile(req.FilePath)
+                                 .AddTag(KmsConstantcs.KmsIdTag, req.KmsId)
+                             , index: KmsConstantcs.KmsIndex).Result;
+                            }
                             //查询文档数量
                             var docTextList = _kMService.GetDocumentByFileID(km.Id, fileid).Result;
                             string fileGuidName = Path.GetFileName(req.FilePath);
@@ -43,8 +72,16 @@ namespace AntSK.Domain.Domain.Service
                     case ImportType.Url:
                         {
                             //导入url                  
-                            var importResult = _memory.ImportWebPageAsync(req.Url, fileid, new TagCollection() { { "kmsid", req.KmsId } }
-                                 , index: "kms").Result;
+                            if (req.IsQA)
+                            {
+                                var importResult = _memory.ImportWebPageAsync(req.Url, fileid, new TagCollection() { { KmsConstantcs.KmsIdTag, req.KmsId } }
+                                , index: KmsConstantcs.KmsIndex, steps: step.ToArray()).Result;
+                            }
+                            else 
+                            {
+                                var importResult = _memory.ImportWebPageAsync(req.Url, fileid, new TagCollection() { { KmsConstantcs.KmsIdTag, req.KmsId } }
+                                , index: KmsConstantcs.KmsIndex).Result;
+                            }  
                             //查询文档数量
                             var docTextList = _kMService.GetDocumentByFileID(km.Id, fileid).Result;
                             req.KmsDetail.Url = req.Url;
@@ -54,8 +91,16 @@ namespace AntSK.Domain.Domain.Service
                     case ImportType.Text:
                         //导入文本
                         {
-                            var importResult = _memory.ImportTextAsync(req.Text, fileid, new TagCollection() { { "kmsid", req.KmsId } }
-                       , index: "kms").Result;
+                            if (req.IsQA)
+                            {
+                                var importResult = _memory.ImportTextAsync(req.Text, fileid, new TagCollection() { { KmsConstantcs.KmsIdTag, req.KmsId } }
+                                , index: KmsConstantcs.KmsIndex, steps: step.ToArray()).Result;
+                            }
+                            else 
+                            {
+                                var importResult = _memory.ImportTextAsync(req.Text, fileid, new TagCollection() { { KmsConstantcs.KmsIdTag, req.KmsId } }
+                                   , index: KmsConstantcs.KmsIndex).Result;
+                            }                  
                             //查询文档数量
                             var docTextList = _kMService.GetDocumentByFileID(km.Id, fileid).Result;
                             req.KmsDetail.Url = req.Url;
@@ -63,17 +108,47 @@ namespace AntSK.Domain.Domain.Service
 
                         }
                         break;
+                    case ImportType.Excel:
+                        using (var fs = File.OpenRead(req.FilePath))
+                        {
+                            var excelList= ExeclHelper.ExcelToList<KMSExcelModel>(fs);           
+                            _memory.Orchestrator.AddHandler<TextExtractionHandler>("extract_text");
+                            _memory.Orchestrator.AddHandler<KMExcelHandler>("antsk_excel_split");
+                            _memory.Orchestrator.AddHandler<GenerateEmbeddingsHandler>("generate_embeddings");
+                            _memory.Orchestrator.AddHandler<SaveRecordsHandler>("save_memory_records");
+
+                            StringBuilder text = new StringBuilder();
+                            foreach (var item in excelList)
+                            {
+                                text.AppendLine(@$"Question:{item.Question}{Environment.NewLine}Answer:{item.Answer}{KmsConstantcs.KMExcelSplit}");                            
+                            }
+                            var importResult = _memory.ImportTextAsync(text.ToString(), fileid, new TagCollection() { { KmsConstantcs.KmsIdTag, req.KmsId } }
+                                  , index: KmsConstantcs.KmsIndex,
+                                  steps: new[]
+                                  {
+                                        "extract_text",
+                                        "antsk_excel_split",
+                                        "generate_embeddings",
+                                        "save_memory_records"
+                                  }
+                                  ).Result;
+                            req.KmsDetail.FileName = req.FileName;
+                            string fileGuidName = Path.GetFileName(req.FilePath);
+                            req.KmsDetail.FileGuidName = fileGuidName;
+                            req.KmsDetail.DataCount = excelList.Count();
+                        }                        
+                        break;
                 }
                 req.KmsDetail.Status = Model.Enum.ImportKmsStatus.Success;
                 _kmsDetails_Repositories.Update(req.KmsDetail);
                 //_kmsDetails_Repositories.GetList(p => p.KmsId == req.KmsId);
-                Console.WriteLine("后台导入任务成功:" + req.KmsDetail.DataCount);
+                _logger.LogInformation("后台导入任务成功:" + req.KmsDetail.DataCount);
             }
             catch (Exception ex)
             {
                 req.KmsDetail.Status = Model.Enum.ImportKmsStatus.Fail;
                 _kmsDetails_Repositories.Update(req.KmsDetail);
-                Console.WriteLine("后台导入任务异常:" + ex.Message);
+                _logger.LogError("后台导入任务异常:" + ex.Message);
             }
         }
     }

src/AntSK.Domain/Domain/Service/KMService.cs

@@ -1,30 +1,95 @@
-using AntSK.Domain.Common.DependencyInjection;
-using AntSK.Domain.Domain.Dto;
+using AntDesign;
+using AntSK.Domain.Common.DependencyInjection;
+using AntSK.Domain.Common.Embedding;
 using AntSK.Domain.Domain.Interface;
+using AntSK.Domain.Domain.Model.Constant;
+using AntSK.Domain.Domain.Model.Dto;
 using AntSK.Domain.Domain.Other;
+using AntSK.Domain.Options;
 using AntSK.Domain.Repositories;
 using AntSK.Domain.Utils;
+using AntSK.OCR;
+using DocumentFormat.OpenXml.Drawing.Diagrams;
 using LLama;
-using LLamaSharp.KernelMemory;
+using Markdig;
+using Microsoft.AspNetCore.Components;
 using Microsoft.Extensions.Configuration;
 using Microsoft.KernelMemory;
 using Microsoft.KernelMemory.Configuration;
-using Microsoft.KernelMemory.ContentStorage.DevTools;
+using Microsoft.KernelMemory.DataFormats;
 using Microsoft.KernelMemory.FileSystem.DevTools;
+using Microsoft.KernelMemory.MemoryStorage;
+using Microsoft.KernelMemory.MemoryStorage.DevTools;
 using Microsoft.KernelMemory.Postgres;
 
 namespace AntSK.Domain.Domain.Service
 {
     [ServiceDescription(typeof(IKMService), ServiceLifetime.Scoped)]
     public class KMService(
-           IConfiguration _config,
-           IKmss_Repositories _kmss_Repositories,
-           IAIModels_Repositories _aIModels_Repositories
-        ) : IKMService
+        IKmss_Repositories _kmss_Repositories,
+        IAIModels_Repositories _aIModels_Repositories,
+        IMessageService? _message,
+        IKernelService _kernelService
+    ) : IKMService
     {
         private MemoryServerless _memory;
 
-        public MemoryServerless GetMemoryByKMS(string kmsID, SearchClientConfig searchClientConfig = null)
+        private List<UploadFileItem> _fileList = [];
+
+        public List<UploadFileItem> FileList => _fileList;
+
+        public MemoryServerless GetMemoryByApp(Apps app)
+        {
+            var chatModel = _aIModels_Repositories.GetFirst(p => p.Id == app.ChatModelID);
+            var embedModel = _aIModels_Repositories.GetFirst(p => p.Id == app.EmbeddingModelID);
+            var chatHttpClient = OpenAIHttpClientHandlerUtil.GetHttpClient(chatModel.EndPoint);
+            var embeddingHttpClient = OpenAIHttpClientHandlerUtil.GetHttpClient(embedModel.EndPoint);
+            SearchClientConfig searchClientConfig;
+            if (string.IsNullOrEmpty(app.RerankModelID))
+            {
+                //不重排直接取查询数
+                searchClientConfig = new SearchClientConfig
+                {
+                    MaxAskPromptSize = app.MaxAskPromptSize,
+                    MaxMatchesCount = app.MaxMatchesCount,
+                    AnswerTokens = app.AnswerTokens,
+                    EmptyAnswer = KmsConstantcs.KmsSearchNull
+                };
+            }
+            else 
+            {
+                //重排取rerank数
+                searchClientConfig = new SearchClientConfig
+                {
+                    MaxAskPromptSize = app.MaxAskPromptSize,
+                    MaxMatchesCount = app.RerankCount,
+                    AnswerTokens = app.AnswerTokens,
+                    EmptyAnswer = KmsConstantcs.KmsSearchNull
+                };
+            }
+           
+
+            var memoryBuild = new KernelMemoryBuilder()
+                  .WithSearchClientConfig(searchClientConfig)
+                  //.WithCustomTextPartitioningOptions(new TextPartitioningOptions
+                  //{
+                  //    MaxTokensPerLine = app.MaxTokensPerLine,
+                  //    MaxTokensPerParagraph = kms.MaxTokensPerParagraph,
+                  //    OverlappingTokens = kms.OverlappingTokens
+                  //})
+                  ;
+            //加载会话模型
+            WithTextGenerationByAIType(memoryBuild, chatModel, chatHttpClient);
+            //加载向量模型
+            WithTextEmbeddingGenerationByAIType(memoryBuild, embedModel, embeddingHttpClient);
+            //加载向量库
+            WithMemoryDbByVectorDB(memoryBuild);
+
+            _memory = memoryBuild.Build<MemoryServerless>();
+            return _memory;
+        }
+
+        public MemoryServerless GetMemoryByKMS(string kmsID)
         {
             //if (_memory.IsNull())
             {
@@ -38,42 +103,52 @@ namespace AntSK.Domain.Domain.Service
                 var embeddingHttpClient = OpenAIHttpClientHandlerUtil.GetHttpClient(embedModel.EndPoint);
 
                 //搜索配置
-                if (searchClientConfig.IsNull())
-                {
-                    searchClientConfig = new SearchClientConfig
-                    {
-                        MaxAskPromptSize = 2048,
-                        MaxMatchesCount = 3,
-                        AnswerTokens = 1000,
-                        EmptyAnswer = "知识库未搜索到相关内容"
-                    };
-                }
+                //if (searchClientConfig.IsNull())
+                //{
+                //    searchClientConfig = new SearchClientConfig
+                //    {
+                //        MaxAskPromptSize = 2048,
+                //        MaxMatchesCount = 3,
+                //        AnswerTokens = 1000,
+                //        EmptyAnswer = KmsConstantcs.KmsSearchNull
+                //    };
+                //}
 
                 var memoryBuild = new KernelMemoryBuilder()
-                .WithSearchClientConfig(searchClientConfig)
-                .WithCustomTextPartitioningOptions(new TextPartitioningOptions
-                {
-                    MaxTokensPerLine = kms.MaxTokensPerLine,
-                    MaxTokensPerParagraph = kms.MaxTokensPerParagraph,
-                    OverlappingTokens = kms.OverlappingTokens
-                });
-                //加载huihu 模型
+                    //.WithSearchClientConfig(searchClientConfig)
+                    .WithCustomTextPartitioningOptions(new TextPartitioningOptions
+                    {
+                        MaxTokensPerLine = kms.MaxTokensPerLine,
+                        MaxTokensPerParagraph = kms.MaxTokensPerParagraph,
+                        OverlappingTokens = kms.OverlappingTokens
+                    });
+                //加载OCR
+                WithOcr(memoryBuild, kms);
+                //加载会话模型
                 WithTextGenerationByAIType(memoryBuild, chatModel, chatHttpClient);
                 //加载向量模型
                 WithTextEmbeddingGenerationByAIType(memoryBuild, embedModel, embeddingHttpClient);
                 //加载向量库
-                WithMemoryDbByVectorDB(memoryBuild, _config);
-
-                _memory = memoryBuild.Build<MemoryServerless>();
+                WithMemoryDbByVectorDB(memoryBuild);
+              
+                _memory = memoryBuild.AddSingleton<IKernelService>(_kernelService).Build<MemoryServerless>();
                 return _memory;
             }
             //else {
             //    return _memory;
             //}
-
         }
 
-        private void WithTextEmbeddingGenerationByAIType(IKernelMemoryBuilder memory, AIModels embedModel, HttpClient embeddingHttpClient)
+        private static void WithOcr(IKernelMemoryBuilder memoryBuild, Kmss kms)
+        {
+            if (kms.IsOCR == 1)
+            {
+                memoryBuild.WithCustomImageOcr(new AntSKOcrEngine());
+            }
+        }
+
+        private void WithTextEmbeddingGenerationByAIType(IKernelMemoryBuilder memory, AIModels embedModel,
+            HttpClient embeddingHttpClient)
         {
             switch (embedModel.AIType)
             {
@@ -84,6 +159,7 @@ namespace AntSK.Domain.Domain.Service
                         EmbeddingModel = embedModel.ModelName
                     }, null, false, embeddingHttpClient);
                     break;
+
                 case Model.Enum.AIType.AzureOpenAI:
                     memory.WithAzureOpenAITextEmbeddingGeneration(new AzureOpenAIConfig()
                     {
@@ -94,15 +170,26 @@ namespace AntSK.Domain.Domain.Service
                         APIType = AzureOpenAIConfig.APITypes.EmbeddingGeneration,
                     });
                     break;
-                case Model.Enum.AIType.LLamaSharp:
-                    var (weights, parameters) = LLamaConfig.GetLLamaConfig(embedModel.ModelName);
-                    var embedder = new LLamaEmbedder(weights, parameters);
-                    memory.WithLLamaSharpTextEmbeddingGeneration(new LLamaSharpTextEmbeddingGenerator(embedder));
+                case Model.Enum.AIType.BgeEmbedding:
+                    string pyDll = embedModel.EndPoint;
+                    string bgeEmbeddingModelName = embedModel.ModelName;
+                    memory.WithBgeTextEmbeddingGeneration(new HuggingfaceTextEmbeddingGenerator(pyDll,bgeEmbeddingModelName));
+                    break;
+                case Model.Enum.AIType.DashScope:
+                    memory.WithDashScopeDefaults(embedModel.ModelKey);
+                    break;
+                case Model.Enum.AIType.OllamaEmbedding:
+                    memory.WithOpenAITextEmbeddingGeneration(new OpenAIConfig()
+                    {
+                        APIKey = "NotNull",
+                        EmbeddingModel = embedModel.ModelName
+                    }, null, false, embeddingHttpClient);
                     break;
             }
         }
 
-        private void WithTextGenerationByAIType(IKernelMemoryBuilder memory, AIModels chatModel, HttpClient chatHttpClient)
+        private void WithTextGenerationByAIType(IKernelMemoryBuilder memory, AIModels chatModel,
+            HttpClient chatHttpClient)
         {
             switch (chatModel.AIType)
             {
@@ -113,6 +200,7 @@ namespace AntSK.Domain.Domain.Service
                         TextModel = chatModel.ModelName
                     }, null, chatHttpClient);
                     break;
+
                 case Model.Enum.AIType.AzureOpenAI:
                     memory.WithAzureOpenAITextGeneration(new AzureOpenAIConfig()
                     {
@@ -123,20 +211,35 @@ namespace AntSK.Domain.Domain.Service
                         APIType = AzureOpenAIConfig.APITypes.TextCompletion,
                     });
                     break;
-                case Model.Enum.AIType.LLamaSharp:
-                    var (weights, parameters) = LLamaConfig.GetLLamaConfig(chatModel.ModelName);
-                    var context = weights.CreateContext(parameters);
-                    var executor = new StatelessExecutor(weights, parameters);
-                    memory.WithLLamaSharpTextGeneration(new LlamaSharpTextGenerator(weights, context, executor));
+                case Model.Enum.AIType.LLamaFactory:
+
+                    memory.WithOpenAITextGeneration(new OpenAIConfig()
+                    {
+                        APIKey = "NotNull",
+                        TextModel = chatModel.ModelName
+                    }, null, chatHttpClient);
+                    break;
+                case Model.Enum.AIType.Ollama:
+                    memory.WithOpenAITextGeneration(new OpenAIConfig()
+                    {
+                        APIKey = "NotNull",
+                        TextModel = chatModel.ModelName
+                    }, null, chatHttpClient);
+                    break;
+                case Model.Enum.AIType.DashScope:
+                    memory.WithDashScopeTextGeneration(new Cnblogs.KernelMemory.AI.DashScope.DashScopeConfig
+                    {
+                        ApiKey = chatModel.ModelKey,
+                    });
                     break;
             }
         }
 
-        private void WithMemoryDbByVectorDB(IKernelMemoryBuilder memory, IConfiguration _config)
+        private void WithMemoryDbByVectorDB(IKernelMemoryBuilder memory)
         {
-            string VectorDb = _config["KernelMemory:VectorDb"].ConvertToString();
-            string ConnectionString = _config["KernelMemory:ConnectionString"].ConvertToString();
-            string TableNamePrefix = _config["KernelMemory:TableNamePrefix"].ConvertToString();
+            string VectorDb = KernelMemoryOption.VectorDb.ConvertToString();
+            string ConnectionString = KernelMemoryOption.ConnectionString.ConvertToString();
+            string TableNamePrefix = KernelMemoryOption.TableNamePrefix.ConvertToString();
             switch (VectorDb)
             {
                 case "Postgres":
@@ -146,51 +249,137 @@ namespace AntSK.Domain.Domain.Service
                         TableNamePrefix = TableNamePrefix
                     });
                     break;
+
                 case "Disk":
-                    memory.WithSimpleFileStorage(new SimpleFileStorageConfig()
+                    memory.WithSimpleVectorDb(new SimpleVectorDbConfig()
                     {
-                        StorageType = FileSystemTypes.Disk
+                        StorageType = FileSystemTypes.Disk,
                     });
                     break;
+
                 case "Memory":
-                    memory.WithSimpleFileStorage(new SimpleFileStorageConfig()
+                    memory.WithSimpleVectorDb(new SimpleVectorDbConfig()
                     {
                         StorageType = FileSystemTypes.Volatile
                     });
                     break;
+                case "Qdrant":
+                    var qdrantConfig = ConnectionString.Split("|");
+                    memory.WithQdrantMemoryDb(qdrantConfig[0],qdrantConfig[1]);
+                    break;
+                case "Redis":
+                    memory.WithRedisMemoryDb(new RedisConfig()
+                    {
+                        ConnectionString = ConnectionString,
+                    });
+                    break;
+                case "AzureAISearch":
+                    var aisearchConfig = ConnectionString.Split("|");
+                    memory.WithAzureAISearchMemoryDb(aisearchConfig[0], aisearchConfig[1]);
+                    break;
             }
         }
 
-        public async Task<List<KMFile>> GetDocumentByFileID(string kmsid, string fileid)
+        public async Task<List<KMFile>> GetDocumentByFileID(string kmsId, string fileId)
         {
-            var _memory = GetMemoryByKMS(kmsid);
-            var memories = await _memory.ListIndexesAsync();
-            var memoryDbs = _memory.Orchestrator.GetMemoryDbs();
-            List<KMFile> docTextList = new List<KMFile>();
+            var memory = GetMemoryByKMS(kmsId);
+            var memories = await memory.ListIndexesAsync();
+            var memoryDbs = memory.Orchestrator.GetMemoryDbs();
+            var docTextList = new List<KMFile>();
 
             foreach (var memoryIndex in memories)
             {
                 foreach (var memoryDb in memoryDbs)
                 {
-
-                    var items = await memoryDb.GetListAsync(memoryIndex.Name, new List<MemoryFilter>() { new MemoryFilter().ByDocument(fileid) }, 100, true).ToListAsync();
-                    foreach (var item in items)
+                    var items = await memoryDb.GetListAsync(memoryIndex.Name, new List<MemoryFilter>() { new MemoryFilter().ByDocument(fileId) }, 1000, true).ToListAsync();
+                    docTextList.AddRange(items.Select(item => new KMFile()
                     {
-                        KMFile file = new KMFile()
-                        {
-                            Text = item.Payload.FirstOrDefault(p => p.Key == "text").Value.ConvertToString(),
-                            Url = item.Payload.FirstOrDefault(p => p.Key == "url").Value.ConvertToString(),
-                            LastUpdate = item.Payload.FirstOrDefault(p => p.Key == "last_update").Value.ConvertToString(),
-                            Schema = item.Payload.FirstOrDefault(p => p.Key == "schema").Value.ConvertToString(),
-                            File = item.Payload.FirstOrDefault(p => p.Key == "file").Value.ConvertToString(),
-                        };
-                        docTextList.Add(file);
-                    }
+                        DocumentId = item.GetDocumentId(),
+                        Text = item.GetPartitionText(),
+                        Url = item.GetWebPageUrl(KmsConstantcs.KmsIndex),
+                        LastUpdate = item.GetLastUpdate().LocalDateTime.ToString("yyyy-MM-dd HH:mm:ss"),
+                        File = item.GetFileName()
+                    }));
                 }
             }
+
             return docTextList;
         }
 
+        public async Task<List<RelevantSource>> GetRelevantSourceList(Apps app ,string msg)
+        {
+            var result = new List<RelevantSource>();
+            if (string.IsNullOrWhiteSpace(app.KmsIdList))
+                return result;
+            var kmsIdList = app.KmsIdList.Split(",");
+            if (!kmsIdList.Any()) return result;
 
+            var memory = GetMemoryByApp(app);
+
+            var filters = kmsIdList.Select(kmsId => new MemoryFilter().ByTag(KmsConstantcs.KmsIdTag, kmsId)).ToList();
+
+            var searchResult = await memory.SearchAsync(msg, index: KmsConstantcs.KmsIndex, filters: filters);
+            if (!searchResult.NoResult)
+            {
+                foreach (var item in searchResult.Results)
+                {
+                    result.AddRange(item.Partitions.Select(part => new RelevantSource()
+                    {
+                        SourceName = item.SourceName,
+                        Text = part.Text,
+                        Relevance = part.Relevance
+                    }));
+                }
+            }
+
+            return result;
+        }
+
+        public bool BeforeUpload(UploadFileItem file)
+        {
+            List<string> types = new List<string>() {
+                "text/plain",
+                "application/msword",
+                "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                "application/vnd.ms-excel",
+                "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                "application/vnd.ms-powerpoint",
+                "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+                "application/pdf",
+                "application/json",
+                "text/x-markdown",
+                "text/markdown",
+                "image/jpeg",
+                "image/png",
+                "image/tiff"
+            };
+
+            string[] exceptExts = [".md", ".pdf"];
+            var validTypes = types.Contains(file.Type) || exceptExts.Contains(file.Ext);
+            if (!validTypes && file.Ext != ".md")
+            {
+                _message.Error("文件格式错误,请重新选择!");
+            }
+            var IsLt500K = file.Size < 1024 * 1024 * 100;
+            if (!IsLt500K)
+            {
+                _message.Error("文件需不大于100MB!");
+            }
+
+            return validTypes && IsLt500K;
+        }
+
+        public void OnSingleCompleted(UploadInfo fileinfo)
+        {
+            if (fileinfo.File.State == UploadState.Success)
+            {
+                //文件列表
+                _fileList.Add(new UploadFileItem()
+                {
+                    FileName = fileinfo.File.FileName,
+                    Url = fileinfo.File.Url = fileinfo.File.Response
+                });
+            }
+        }
     }
-}
+}

src/AntSK.Domain/Domain/Service/KernelService.cs

@@ -2,19 +2,18 @@
 using AntSK.Domain.Common.DependencyInjection;
 using AntSK.Domain.Domain.Interface;
 using AntSK.Domain.Domain.Other;
-using AntSK.Domain.Model;
 using AntSK.Domain.Repositories;
 using AntSK.Domain.Utils;
-using LLama;
-using LLamaSharp.SemanticKernel.TextCompletion;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.SemanticKernel;
 using Microsoft.SemanticKernel.Plugins.Core;
 using Microsoft.SemanticKernel.TextGeneration;
 using RestSharp;
-using System;
 using ServiceLifetime = AntSK.Domain.Common.DependencyInjection.ServiceLifetime;
 using AntSK.LLM.Mock;
+using AntSK.Domain.Domain.Model.Enum;
+using Microsoft.SemanticKernel.ChatCompletion;
+using Microsoft.Extensions.Logging;
 
 namespace AntSK.Domain.Domain.Service
 {
@@ -24,20 +23,24 @@ namespace AntSK.Domain.Domain.Service
         private readonly IApis_Repositories _apis_Repositories;
         private readonly IAIModels_Repositories _aIModels_Repositories;
         private readonly FunctionService _functionService;
+        private readonly IServiceProvider _serviceProvider;
+        private Kernel _kernel;
+        private readonly ILogger<KernelService> _logger;
 
         public KernelService(
               IApis_Repositories apis_Repositories,
               IAIModels_Repositories aIModels_Repositories,
-              FunctionService functionService)
+              FunctionService functionService,
+              IServiceProvider serviceProvider,
+               ILogger<KernelService> logger)
         {
             _apis_Repositories = apis_Repositories;
             _aIModels_Repositories = aIModels_Repositories;
             _functionService = functionService;
+            _serviceProvider = serviceProvider;
+            _logger = logger;
         }
 
-        private Kernel _kernel;
-
-
         /// <summary>
         /// 获取kernel实例，依赖注入不好按每个用户去Import不同的插件，所以每次new一个新的kernel
         /// </summary>
@@ -53,7 +56,7 @@ namespace AntSK.Domain.Domain.Service
                 var chatHttpClient = OpenAIHttpClientHandlerUtil.GetHttpClient(chatModel.EndPoint);
 
                 var builder = Kernel.CreateBuilder();
-                WithTextGenerationByAIType(builder, app, chatModel, chatHttpClient);
+                WithTextGenerationByAIType(builder, chatModel, chatHttpClient);
 
                 _kernel = builder.Build();
                 RegisterPluginsWithKernel(_kernel);
@@ -65,7 +68,18 @@ namespace AntSK.Domain.Domain.Service
             //}
         }
 
-        private void WithTextGenerationByAIType(IKernelBuilder builder, Apps app, AIModels chatModel, HttpClient chatHttpClient)
+        public Kernel GetKernelByAIModelID(string modelid)
+        {
+            var chatModel = _aIModels_Repositories.GetById(modelid);
+            var chatHttpClient = OpenAIHttpClientHandlerUtil.GetHttpClient(chatModel.EndPoint);
+            var builder = Kernel.CreateBuilder();
+            WithTextGenerationByAIType(builder, chatModel, chatHttpClient);
+            _kernel = builder.Build();
+            RegisterPluginsWithKernel(_kernel);
+            return _kernel;
+        }
+
+        private void WithTextGenerationByAIType(IKernelBuilder builder,AIModels chatModel, HttpClient chatHttpClient)
         {
             switch (chatModel.AIType)
             {
@@ -84,18 +98,55 @@ namespace AntSK.Domain.Domain.Service
                         );
                     break;
 
-                case Model.Enum.AIType.LLamaSharp:
-                    var (weights, parameters) = LLamaConfig.GetLLamaConfig(chatModel.ModelName);
-                    var ex = new StatelessExecutor(weights, parameters);
-                    builder.Services.AddKeyedSingleton<ITextGenerationService>("local-llama", new LLamaSharpTextCompletion(ex));
+                case Model.Enum.AIType.SparkDesk:
+
+                    var settings = chatModel.ModelKey.Split("|");
+
+                    Sdcb.SparkDesk.ModelVersion modelVersion = Sdcb.SparkDesk.ModelVersion.V3_5;
+
+                    switch (chatModel.ModelName)
+                    {
+                        case "V3_5":
+                            modelVersion = Sdcb.SparkDesk.ModelVersion.V3_5;
+                            break;
+                        case "V3":
+                            modelVersion = Sdcb.SparkDesk.ModelVersion.V3;
+                            break;
+                        case "V2":
+                            modelVersion = Sdcb.SparkDesk.ModelVersion.V2;
+                            break;
+                        case "V1_5":
+                            modelVersion = Sdcb.SparkDesk.ModelVersion.V1_5;
+                            break;
+                    }
+
+                    SparkDeskOptions options = new SparkDeskOptions { AppId = settings[0], ApiSecret = settings[1], ApiKey = settings[2], ModelVersion = modelVersion };
+                
+                    builder.Services.AddKeyedSingleton<ITextGenerationService>("spark-desk", new SparkDeskTextCompletion(options, chatModel.Id));
+                    builder.Services.AddKeyedSingleton<IChatCompletionService>("spark-desk-chat", new SparkDeskChatCompletion(options, chatModel.Id));
                     break;
 
-                case Model.Enum.AIType.SparkDesk:
-                    var options = new SparkDeskOptions { AppId = chatModel.EndPoint, ApiSecret = chatModel.ModelKey, ApiKey = chatModel.ModelName, ModelVersion = Sdcb.SparkDesk.ModelVersion.V3_5 };
-                    builder.Services.AddKeyedSingleton<ITextGenerationService>("spark-desk", new SparkDeskTextCompletion(options, app.Id));
+                case Model.Enum.AIType.DashScope:
+                    builder.Services.AddDashScopeChatCompletion(chatModel.ModelKey, chatModel.ModelName);
                     break;
+
                 case Model.Enum.AIType.Mock:
                     builder.Services.AddKeyedSingleton<ITextGenerationService>("mock", new MockTextCompletion());
+                    builder.Services.AddKeyedSingleton<IChatCompletionService>("mock-chat", new MockChatCompletion());
+                    break;
+                case Model.Enum.AIType.LLamaFactory:
+                    builder.AddOpenAIChatCompletion(
+                     modelId: chatModel.ModelName,
+                     apiKey: "NotNull",
+                     httpClient: chatHttpClient
+                       );
+                    break;
+                case AIType.Ollama:
+                    builder.AddOpenAIChatCompletion(
+                     modelId: chatModel.ModelName,
+                     apiKey: "NotNull",
+                     httpClient: chatHttpClient
+                       );
                     break;
             }
         }
@@ -108,13 +159,27 @@ namespace AntSK.Domain.Domain.Service
         public void ImportFunctionsByApp(Apps app, Kernel _kernel)
         {
             //插件不能重复注册，否则会异常
-            if (_kernel.Plugins.Any(p => p.Name == "AntSkFunctions"))
+            if (_kernel.Plugins.Any(p => p.Name == "AntSKFunctions"))
             {
                 return;
             }
-            List<KernelFunction> apiFunctions = new List<KernelFunction>();
+            List<KernelFunction> functions = new List<KernelFunction>();
 
             //API插件
+            ImportApiFunction(app, functions);
+            //本地函数插件
+            ImportNativeFunction(app, functions);
+
+            _kernel.ImportPluginFromFunctions("AntSKFunctions", functions);
+        }
+
+        /// <summary>
+        /// 导入API插件
+        /// </summary>
+        /// <param name="app"></param>
+        /// <param name="functions"></param>
+        private void ImportApiFunction(Apps app, List<KernelFunction> functions)
+        {
             if (!string.IsNullOrWhiteSpace(app.ApiFunctionList))
             {
                 //开启自动插件调用
@@ -123,17 +188,26 @@ namespace AntSK.Domain.Domain.Service
 
                 foreach (var api in apiList)
                 {
+                    var returnType = new KernelReturnParameterMetadata() { Description = api.OutputPrompt };
                     switch (api.Method)
                     {
                         case HttpMethodType.Get:
-                            apiFunctions.Add(_kernel.CreateFunctionFromMethod((string msg) =>
+
+                            var getParametes = new List<KernelParameterMetadata>() {
+                                     new KernelParameterMetadata("jsonbody"){
+                                      ParameterType=typeof(string),
+                                      Description=$"背景文档:{Environment.NewLine}{api.InputPrompt} {Environment.NewLine}提取出对应的json格式字符串，参考如下格式:{Environment.NewLine}{api.Query}"
+                                    }
+                                };
+                            functions.Add(_kernel.CreateFunctionFromMethod((string jsonbody) =>
                             {
                                 try
                                 {
-                                    Console.WriteLine(msg);
+                                    //将json 转换为query参数
+                                    var queryString = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonbody);
                                     RestClient client = new RestClient();
                                     RestRequest request = new RestRequest(api.Url, Method.Get);
-                                    foreach (var header in api.Header.Split("\n"))
+                                    foreach (var header in api.Header.ConvertToString().Split("\n"))
                                     {
                                         var headerArray = header.Split(":");
                                         if (headerArray.Length == 2)
@@ -142,13 +216,9 @@ namespace AntSK.Domain.Domain.Service
                                         }
                                     }
                                     //这里应该还要处理一次参数提取，等后面再迭代
-                                    foreach (var query in api.Query.Split("\n"))
+                                    foreach (var q in queryString)
                                     {
-                                        var queryArray = query.Split("=");
-                                        if (queryArray.Length == 2)
-                                        {
-                                            request.AddQueryParameter(queryArray[0], queryArray[1]);
-                                        }
+                                        request.AddQueryParameter(q.Key, q.Value);
                                     }
                                     var result = client.Execute(request);
                                     return result.Content;
@@ -157,18 +227,24 @@ namespace AntSK.Domain.Domain.Service
                                 {
                                     return "调用失败：" + ex.Message;
                                 }
-                            }, api.Name, $"{api.Describe}"));
+                            }, api.Name, api.Describe, getParametes, returnType));
                             break;
-
                         case HttpMethodType.Post:
-                            apiFunctions.Add(_kernel.CreateFunctionFromMethod((string msg) =>
+                            //处理json body
+                            var postParametes = new List<KernelParameterMetadata>() {
+                                    new KernelParameterMetadata("jsonbody"){
+                                      ParameterType=typeof(string),
+                                      Description=$"背景文档:{Environment.NewLine}{api.InputPrompt} {Environment.NewLine}提取出对应的json格式字符串，参考如下格式:{Environment.NewLine}{api.JsonBody}"
+                                    }
+                                };
+                            functions.Add(_kernel.CreateFunctionFromMethod((string jsonBody) =>
                             {
                                 try
                                 {
-                                    Console.WriteLine(msg);
+                                    _logger.LogInformation(jsonBody);
                                     RestClient client = new RestClient();
                                     RestRequest request = new RestRequest(api.Url, Method.Post);
-                                    foreach (var header in api.Header.Split("\n"))
+                                    foreach (var header in api.Header.ConvertToString().Split("\n"))
                                     {
                                         var headerArray = header.Split(":");
                                         if (headerArray.Length == 2)
@@ -177,7 +253,7 @@ namespace AntSK.Domain.Domain.Service
                                         }
                                     }
                                     //这里应该还要处理一次参数提取，等后面再迭代
-                                    request.AddJsonBody(api.JsonBody);
+                                    request.AddJsonBody(jsonBody.ConvertToString());
                                     var result = client.Execute(request);
                                     return result.Content;
                                 }
@@ -185,18 +261,28 @@ namespace AntSK.Domain.Domain.Service
                                 {
                                     return "调用失败：" + ex.Message;
                                 }
-                            }, api.Name, $"{api.Describe}"));
+                            }, api.Name, api.Describe, postParametes, returnType));
                             break;
                     }
                 }
             }
 
-            //本地函数插件
+        }
+
+        /// <summary>
+        /// 导入原生插件
+        /// </summary>
+        /// <param name="app"></param>
+        /// <param name="functions"></param>
+        private void ImportNativeFunction(Apps app, List<KernelFunction> functions)
+        {
             if (!string.IsNullOrWhiteSpace(app.NativeFunctionList))//需要添加判断应用是否开启了本地函数插件
             {
                 var nativeIdList = app.NativeFunctionList.Split(",");
 
                 _functionService.SearchMarkedMethods();
+                using var scope = _serviceProvider.CreateScope();
+
                 foreach (var func in _functionService.Functions)
                 {
                     if (nativeIdList.Contains(func.Key))
@@ -204,11 +290,11 @@ namespace AntSK.Domain.Domain.Service
                         var methodInfo = _functionService.MethodInfos[func.Key];
                         var parameters = methodInfo.Parameters.Select(x => new KernelParameterMetadata(x.ParameterName) { ParameterType = x.ParameterType, Description = x.Description });
                         var returnType = new KernelReturnParameterMetadata() { ParameterType = methodInfo.ReturnType.ParameterType, Description = methodInfo.ReturnType.Description };
-                        apiFunctions.Add(_kernel.CreateFunctionFromMethod((object[] args) => func.Value(args), func.Key, methodInfo.Description, parameters, returnType));
+                        var target = ActivatorUtilities.CreateInstance(scope.ServiceProvider, func.Value.DeclaringType);
+                        functions.Add(_kernel.CreateFunctionFromMethod(func.Value, target, func.Key, methodInfo.Description, parameters, returnType));
                     }
                 }
             }
-            _kernel.ImportPluginFromFunctions("AntSkFunctions", apiFunctions);
         }
 
         /// <summary>
@@ -218,8 +304,8 @@ namespace AntSK.Domain.Domain.Service
         private void RegisterPluginsWithKernel(Kernel kernel)
         {
             kernel.ImportPluginFromObject(new ConversationSummaryPlugin(), "ConversationSummaryPlugin");
-            kernel.ImportPluginFromObject(new TimePlugin(), "TimePlugin");
-            kernel.ImportPluginFromPromptDirectory(Path.Combine(RepoFiles.SamplePluginsPath(), "KMSPlugin"));
+            //kernel.ImportPluginFromObject(new TimePlugin(), "TimePlugin");
+            kernel.ImportPluginFromPromptDirectory(System.IO.Path.Combine(RepoFiles.SamplePluginsPath(), "KMSPlugin"));
         }
 
         /// <summary>
@@ -234,8 +320,8 @@ namespace AntSK.Domain.Domain.Service
             KernelFunction sunFun = _kernel.Plugins.GetFunction("ConversationSummaryPlugin", "SummarizeConversation");
             var summary = await _kernel.InvokeAsync(sunFun, new() { ["input"] = $"内容是：{history.ToString()} {Environment.NewLine} 请注意用中文总结" });
             string his = summary.GetValue<string>();
-            var msg = $"history：{history.ToString()}{Environment.NewLine} user：{questions}"; ;
+            var msg = $"history：{Environment.NewLine}{his}{Environment.NewLine} user：{questions}{Environment.NewLine}"; 
             return msg;
         }
     }
-}
+}

src/AntSK.Domain/Domain/Service/LLamaFactoryService.cs

@@ -0,0 +1,210 @@
+using Amazon.Runtime.Internal.Util;
+using AntSK.Domain.Common.DependencyInjection;
+using AntSK.Domain.Domain.Interface;
+using AntSK.Domain.Domain.Model.Dto;
+using AntSK.Domain.Options;
+using AntSK.LLamaFactory.Model;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Serilog;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.Tracing;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace AntSK.Domain.Domain.Service
+{
+    [ServiceDescription(typeof(ILLamaFactoryService), ServiceLifetime.Singleton)]
+    public class LLamaFactoryService(ILogger<LLamaFactoryService> _logger) : ILLamaFactoryService
+    {
+        private Process process;
+
+        public static bool isProcessComplete = false;
+
+        private readonly object _syncLock = new object();
+        private List<LLamaModel> modelList = new List<LLamaModel>();
+
+
+        public delegate Task LogMessageHandler(string message);
+        public event LogMessageHandler LogMessageReceived;
+        protected virtual async Task OnLogMessageReceived(string message)
+        {
+            LogMessageReceived?.Invoke(message);
+        }
+
+        public async Task PipInstall()
+        {
+
+            var cmdTask = Task.Factory.StartNew(() =>
+            {
+
+                var isProcessComplete = false;
+
+                process = new Process
+                {
+                    StartInfo = new ProcessStartInfo
+                    {
+                        FileName = "pip",
+                        Arguments = "install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple",
+                        UseShellExecute = false,
+                        RedirectStandardOutput = true,
+                        RedirectStandardError = true,
+                        WorkingDirectory = AppDomain.CurrentDomain.BaseDirectory,
+                    }
+                };  
+                process.OutputDataReceived += (sender, eventArgs) =>
+                {
+                    _logger.LogInformation($"{eventArgs.Data}");
+                    OnLogMessageReceived(eventArgs.Data);
+                };
+                process.ErrorDataReceived += (sender, eventArgs) =>
+                {
+                    _logger.LogInformation($"{eventArgs.Data}");
+                    OnLogMessageReceived(eventArgs.Data);
+                };
+                process.Start();
+                process.BeginOutputReadLine();
+                process.BeginErrorReadLine();
+                process.WaitForExit();
+                OnLogMessageReceived("--------------------完成--------------------");
+            }, TaskCreationOptions.LongRunning);
+            await cmdTask;
+        }
+        public async Task PipInstallName(string name)
+        {
+
+            var cmdTask = Task.Factory.StartNew(() =>
+            {
+
+                var isProcessComplete = false;
+
+                process = new Process
+                {
+                    StartInfo = new ProcessStartInfo
+                    {
+                        FileName = "pip",
+                        Arguments = $"install {name} -i https://pypi.tuna.tsinghua.edu.cn/simple",
+                        UseShellExecute = false,
+                        RedirectStandardOutput = true,
+                        RedirectStandardError = true,
+                        WorkingDirectory = AppDomain.CurrentDomain.BaseDirectory,
+                    }
+                };
+                process.OutputDataReceived += (sender, eventArgs) =>
+                {
+                    Log.Information($"{eventArgs.Data}");
+                    OnLogMessageReceived(eventArgs.Data);
+                };
+                process.ErrorDataReceived += (sender, eventArgs) =>
+                {
+                    Log.Information($"{eventArgs.Data}");
+                    OnLogMessageReceived(eventArgs.Data);
+                };
+                process.Start();
+                process.BeginOutputReadLine();
+                process.BeginErrorReadLine();
+                process.WaitForExit();
+                OnLogMessageReceived("--------------------完成--------------------");
+            }, TaskCreationOptions.LongRunning);
+            await cmdTask;
+        }
+        public async Task StartLLamaFactory(string modelName)
+        {
+            var cmdTask = Task.Factory.StartNew(() =>
+            {
+
+                var isProcessComplete = false;
+
+                process = new Process
+                {
+                    StartInfo = new ProcessStartInfo
+                    {
+                        FileName = "python",
+                        Arguments = "api_antsk.py --model_name_or_path " + modelName + " --template default ",
+                        UseShellExecute = false,
+                        RedirectStandardOutput = true,
+                        RedirectStandardError=true,
+                        WorkingDirectory = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location), "llamafactory"),
+                    }
+                };
+                process.StartInfo.Environment["CUDA_VISIBLE_DEVICES"] = Environment.GetEnvironmentVariable("CUDA_VISIBLE_DEVICES") ?? "0";
+                process.StartInfo.Environment["API_PORT"] = "8000";
+                process.StartInfo.EnvironmentVariables["USE_MODELSCOPE_HUB"] = Environment.GetEnvironmentVariable("USE_MODELSCOPE_HUB") ?? "1";
+                process.OutputDataReceived += (sender, eventArgs) =>
+                {
+                    _logger.LogInformation($"{eventArgs.Data}");
+                    OnLogMessageReceived(eventArgs.Data);
+                };
+                process.ErrorDataReceived += (sender, eventArgs) =>
+                {
+                    _logger.LogInformation($"{eventArgs.Data}");
+                    OnLogMessageReceived(eventArgs.Data);
+                };
+                process.Start();
+                process.BeginOutputReadLine();
+                process.BeginErrorReadLine();
+                process.WaitForExit();
+
+                OnLogMessageReceived("--------------------完成--------------------");
+            }, TaskCreationOptions.LongRunning);
+            await cmdTask;
+        }
+
+        private void Process_OutputDataReceived(object sender, DataReceivedEventArgs e)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string WaitForProcessExit()
+        {
+            process.WaitForExit();
+            return process.StandardOutput.ReadToEnd();
+        }
+
+        public void KillProcess()
+        {
+
+            try
+            {
+                Process[] processes = Process.GetProcesses();
+                foreach (Process process1 in processes)
+                {
+                    if (process1.ProcessName.ToLower() == "python")
+                    {
+                        process1.Kill();
+                        _logger.LogInformation("kill python");
+                    }
+                }
+            }
+            catch (InvalidOperationException ex)
+            {
+                // Process already exited.
+            }
+
+        }
+
+        public List<LLamaModel> GetLLamaFactoryModels()
+        {
+            if (modelList.Count==0)
+            {
+                string jsonString = File.ReadAllText(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "modelList.json"));
+
+                // 反序列化 JSON 字符串到相应的 C# 对象
+                var Models = JsonConvert.DeserializeObject<List<LLamaFactoryModel>>(jsonString);
+                foreach (var model in Models)
+                {
+                    foreach (var m in model.Models)
+                    {
+                        modelList.Add(new LLamaModel() { Name=m.Key, ModelScope=m.Value.MODELSCOPE });
+                    }
+                }
+            }         
+            return modelList;
+        }
+    }
+}

src/AntSK.Domain/Domain/Service/OllamaService.cs

@@ -0,0 +1,74 @@
+using AntSK.Domain.Common.DependencyInjection;
+using AntSK.Domain.Domain.Interface;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Serilog;
+using AntSK.Domain.Utils;
+
+namespace AntSK.Domain.Domain.Service
+{
+    [ServiceDescription(typeof(IOllamaService), ServiceLifetime.Singleton)]
+    public class OllamaService : IOllamaService
+    {
+        private Process process;
+        public delegate Task LogMessageHandler(string message);
+        public event LogMessageHandler LogMessageReceived;
+        protected virtual async Task OnLogMessageReceived(string message)
+        {
+            LogMessageReceived?.Invoke(message);
+        }
+
+        public async Task StartOllama(string modelName)
+        {
+            Console.OutputEncoding = Encoding.UTF8;
+            var cmdTask = Task.Factory.StartNew(() =>
+            {
+
+                var isProcessComplete = false;
+
+                process = new Process
+                {
+                    StartInfo = new ProcessStartInfo
+                    {
+                        FileName = "ollama",
+                        Arguments = "run " + modelName,
+                        UseShellExecute = false,
+                        RedirectStandardOutput = true,
+                        RedirectStandardError = true,
+                    }
+                };
+                process.OutputDataReceived += (sender, eventArgs) =>
+                {
+                    Log.Information($"{eventArgs.Data.ConvertToString()}");
+                    if (!eventArgs.Data.ConvertToString().Contains("The handle is invalid"))
+                    {
+                        OnLogMessageReceived(eventArgs.Data.ConvertToString());
+                    }
+                };
+                process.ErrorDataReceived += (sender, eventArgs) =>
+                {
+                    Log.Error($"{eventArgs.Data.ConvertToString()}");
+                    if (!eventArgs.Data.ConvertToString().Contains("The handle is invalid"))
+                    {
+                        OnLogMessageReceived(eventArgs.Data.ConvertToString());
+                    }
+                };
+                process.StartInfo.StandardOutputEncoding = Encoding.UTF8;
+                process.StartInfo.StandardErrorEncoding = Encoding.UTF8;
+
+                process.Start();
+                process.BeginOutputReadLine();
+                process.BeginErrorReadLine();
+                process.WaitForExit();
+
+                OnLogMessageReceived("--------------------完成--------------------");
+            }, TaskCreationOptions.LongRunning);
+            await cmdTask;
+        }
+    
+    }
+}

src/AntSK.Domain/Map/AutoMapProfile.cs

@@ -1,13 +0,0 @@
-using AutoMapper;
-
-namespace AntSK.Domain.Map
-{
-    public class AutoMapProfile : Profile
-    {
-        public AutoMapProfile()
-        {
-
-
-        }
-    }
-}

src/AntSK.Domain/Map/MapperExtend.cs

@@ -1,48 +0,0 @@
-using AutoMapper;
-
-namespace AntSK.Domain.Map
-{
-    public static class MapperExtend
-    {
-        /// <summary>
-        /// Entity集合转DTO集合
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="value"></param>
-        /// <returns></returns>
-        public static List<T> ToDTOList<T>(this object value)
-        {
-            if (value == null)
-                return new List<T>();
-
-            return Mapper.Map<List<T>>(value);
-        }
-        /// <summary>
-        /// Entity转DTO
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="value"></param>
-        /// <returns></returns>
-        public static T ToDTO<T>(this object value)
-        {
-            if (value == null)
-                return default(T);
-
-            return Mapper.Map<T>(value);
-        }
-
-        /// <summary>
-        /// 给已有对象map,适合update场景，如需过滤空值需要在AutoMapProfile 设置
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="self"></param>
-        /// <param name="result"></param>
-        /// <returns></returns>
-        public static T MapTo<T>(this object self, T result)
-        {
-            if (self == null)
-                return default(T);
-            return (T)Mapper.Map(self, result, self.GetType(), typeof(T));
-        }
-    }
-}

src/AntSK.Domain/Map/MapperRegister.cs

@@ -1,30 +0,0 @@
-using AutoMapper;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace AntSK.Domain.Map
-{
-    public static class MapperRegister
-    {
-        public static void AddMapper(this IServiceCollection services)
-        {
-            var config = new MapperConfiguration(cfg =>
-            {
-                cfg.CreateMissingTypeMaps = true;
-                cfg.ValidateInlineMaps = false;
-                cfg.ShouldMapMethod = m => false;
-                cfg.AddProfile<AutoMapProfile>();
-            });
-
-            IMapper mapper = config.CreateMapper();
-
-            //启动实体映射
-            Mapper.Initialize(cfg =>
-            {
-                cfg.CreateMissingTypeMaps = true;
-                cfg.ValidateInlineMaps = false;
-                cfg.ShouldMapMethod = m => false;
-                cfg.AddProfile<AutoMapProfile>();
-            });
-        }
-    }
-}

src/AntSK.Domain/Model/Enum/AIModelType.cs

@@ -1,23 +0,0 @@
-namespace AntSK.Domain.Model.Enum
-{
-    /// <summary>
-    /// AI类型
-    /// </summary>
-    public enum AIType
-    {
-        OpenAI = 1,
-        AzureOpenAI = 2,
-        LLamaSharp=3,
-        SparkDesk=4,
-        Mock=5,
-    }
-
-    /// <summary>
-    /// 模型类型
-    /// </summary>
-    public enum AIModelType
-    {
-        Chat = 1,
-        Embedding = 2,
-    }
-}

src/AntSK.Domain/Model/MessageInfo.cs

@@ -1,16 +0,0 @@
-namespace AntSK.Domain.Model
-{
-    public class MessageInfo
-    {
-        public string ID { get; set; } = "";
-        public string Context { get; set; } = "";
-        public string HtmlAnswers { get; set; } = "";
-
-        /// <summary>
-        /// 发送是true  接收是false
-        /// </summary>
-        public bool IsSend { get; set; } = false;
-        public DateTime CreateTime { get; set; }
-
-    }
-}

src/AntSK.Domain/Options/FileDirOption.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AntSK.Domain.Options
+{
+    public class FileDirOption
+    {
+        public static string DirectoryPath { get; set; } = Directory.GetCurrentDirectory();
+    }
+}

src/AntSK.Domain/Options/LLamaSharpOption.cs

@@ -1,12 +0,0 @@
-namespace AntSK.Domain.Options
-{
-    public class LLamaSharpOption
-    {
-        public static string RunType { get; set; }
-        public static string Chat { get; set; }
-
-        public static string Embedding { get; set; }
-
-        public static string FileDirectory { get; set; }
-    }
-}

src/AntSK.Domain/Repositories/AI/Api/Apis.cs

@@ -1,4 +1,4 @@
-using AntSK.Domain.Model;
+using AntSK.Domain.Domain.Model.Enum;
 using SqlSugar;
 using System.ComponentModel.DataAnnotations;
 

src/AntSK.Domain/Repositories/AI/App/Apps.cs

@@ -20,11 +20,12 @@ namespace AntSK.Domain.Repositories
         /// </summary>
         [Required]
         public string Describe { get; set; }
+
         /// <summary>
         /// 图标
         /// </summary>
         [Required]
-        public string Icon { get; set; }
+        public string Icon { get; set; } = "windows";
 
         /// <summary>
         /// 类型
@@ -38,6 +39,15 @@ namespace AntSK.Domain.Repositories
         [Required]
         public string? ChatModelID { get; set; }
 
+        /// <summary>
+        /// Embedding 模型Id
+        /// </summary>
+        public string? EmbeddingModelID { get; set; }
+
+        public string? RerankModelID { get; set; }
+
+
+        public string? ImageModelID { get; set; }
         /// <summary>
         /// 温度
         /// </summary>
@@ -47,6 +57,7 @@ namespace AntSK.Domain.Repositories
         /// <summary>
         /// 提示词
         /// </summary>
+        [SugarColumn(ColumnDataType = "varchar(2000)")]
         public string? Prompt { get; set; }
 
         /// <summary>
@@ -61,14 +72,41 @@ namespace AntSK.Domain.Repositories
         [SugarColumn(ColumnDataType = "varchar(1000)")]
         public string? NativeFunctionList { get; set; }
 
-
         /// <summary>
         /// 知识库ID列表
         /// </summary>
+        [SugarColumn(ColumnDataType = "varchar(1000)")]
         public string? KmsIdList { get; set; }
+
         /// <summary>
         /// API调用秘钥
         /// </summary>
         public string? SecretKey { get; set; }
+
+        /// <summary>
+        /// 相似度
+        /// </summary>
+        [SugarColumn(DefaultValue = "70")]
+        public double Relevance { get; set; } = 70f;
+
+        /// <summary>
+        /// 提问最大token数
+        /// </summary>
+        [SugarColumn(DefaultValue = "2048")]
+        public int MaxAskPromptSize { get; set; } = 2048;
+        /// <summary>
+        /// 向量匹配数
+        /// </summary>
+        [SugarColumn(DefaultValue = "3")]
+        public int MaxMatchesCount { get; set; } = 3;
+
+
+        [SugarColumn(DefaultValue = "20")]
+        public int RerankCount { get; set; } = 20;
+        /// <summary>
+        /// 回答最大token数
+        /// </summary>
+        [SugarColumn(DefaultValue = "2048")]
+        public int AnswerTokens { get; set; } = 2048;
     }
-}
+}

src/AntSK.Domain/Repositories/AI/Chat/Chats.cs

@@ -0,0 +1,41 @@
+using AntSK.Domain.Domain.Model.Enum;
+using SqlSugar;
+using System.ComponentModel.DataAnnotations;
+
+namespace AntSK.Domain.Repositories
+{
+    [SugarTable("Chats")]
+    public partial class Chats
+    {
+        [SugarColumn(IsPrimaryKey = true)]
+        public string Id { get; set; }
+
+        /// <summary>
+        /// 用户名
+        /// </summary>
+        public string UserName { get; set; }
+        /// <summary>
+        /// 应用ID
+        /// </summary>
+        public string AppId { get; set; }
+        /// <summary>
+        /// 消息内容
+        /// </summary>
+        [SugarColumn(ColumnDataType = "varchar(4000)")]
+        public string Context { get; set; } = "";
+
+        /// <summary>
+        /// 发送是true  接收是false
+        /// </summary>
+        public bool IsSend { get; set; } = false;
+        /// <summary>
+        /// 创建事件
+        /// </summary>
+        public DateTime CreateTime { get; set; }
+
+        /// <summary>
+        /// 文件名
+        /// </summary>
+        public string? FileName { get; set; }
+    }
+}

src/AntSK.Domain/Repositories/AI/Chat/Chats_Repositories.cs

@@ -0,0 +1,11 @@
+
+using AntSK.Domain.Common.DependencyInjection;
+using AntSK.Domain.Repositories.Base;
+
+namespace AntSK.Domain.Repositories
+{
+    [ServiceDescription(typeof(IChats_Repositories), ServiceLifetime.Scoped)]
+    public class Chats_Repositories : Repository<Chats>, IChats_Repositories
+    {
+    }
+}

src/AntSK.Domain/Repositories/AI/Chat/IChats_Repositories.cs

@@ -0,0 +1,8 @@
+using AntSK.Domain.Repositories.Base;
+
+namespace AntSK.Domain.Repositories
+{
+    public interface IChats_Repositories : IRepository<Chats>
+    {
+    }
+}

src/AntSK.Domain/Repositories/AI/Fun/Funs.cs

@@ -0,0 +1,20 @@
+using AntSK.Domain.Domain.Model.Enum;
+using SqlSugar;
+using System.ComponentModel.DataAnnotations;
+
+namespace AntSK.Domain.Repositories
+{
+    [SugarTable("Funs")]
+    public partial class Funs
+    {
+        [SugarColumn(IsPrimaryKey = true)]
+        public string Id { get; set; }
+
+        /// <summary>
+        /// 接口描述
+        /// </summary>
+        [Required]
+        public string Path { get; set; }
+      
+    }
+}

src/AntSK.Domain/Repositories/AI/Fun/Funs_Repositories.cs

@@ -0,0 +1,11 @@
+
+using AntSK.Domain.Common.DependencyInjection;
+using AntSK.Domain.Repositories.Base;
+
+namespace AntSK.Domain.Repositories
+{
+    [ServiceDescription(typeof(IFuns_Repositories), ServiceLifetime.Scoped)]
+    public class Funs_Repositories : Repository<Funs>, IFuns_Repositories
+    {
+    }
+}

src/AntSK.Domain/Repositories/AI/Fun/IFuns_Repositories.cs

@@ -0,0 +1,8 @@
+using AntSK.Domain.Repositories.Base;
+
+namespace AntSK.Domain.Repositories
+{
+    public interface IFuns_Repositories : IRepository<Funs>
+    {
+    }
+}

src/AntSK.Domain/Repositories/AI/Kms/Kmss.cs

@@ -12,7 +12,7 @@ namespace AntSK.Domain.Repositories
         /// 图标
         /// </summary>
         [Required]
-        public string Icon { get; set; }
+        public string Icon { get; set; } = "question-circle";
         /// <summary>
         /// 名称
         /// </summary>
@@ -55,6 +55,7 @@ namespace AntSK.Domain.Repositories
         [SugarColumn(DefaultValue = "49")]
         public int OverlappingTokens { get; set; } = 49;
 
-
+        [SugarColumn(DefaultValue = "0")]
+        public int IsOCR { get; set; } = 0;
     }
 }

src/AntSK.Domain/Repositories/AI/KmsDetail/KmsDetails.cs

@@ -1,4 +1,4 @@
-using AntSK.Domain.Model.Enum;
+using AntSK.Domain.Domain.Model.Enum;
 using SqlSugar;
 
 namespace AntSK.Domain.Repositories

src/AntSK.Domain/Repositories/Base/IRepository.cs

@@ -1,4 +1,4 @@
-using AntSK.Domain.Model;
+using AntSK.Domain.Domain.Model;
 using SqlSugar;
 using System.Linq.Expressions;
 

src/AntSK.Domain/Repositories/Base/Repository.cs

@@ -1,5 +1,6 @@
-using AntSK.Domain.Map;
-using AntSK.Domain.Model;
+using AntSK.Domain.Common.Map;
+using AntSK.Domain.Domain.Model;
+
 using SqlSugar;
 using System.Linq.Expressions;
 

src/AntSK.Domain/Repositories/Setting/AIModel/AIModels.cs

@@ -1,4 +1,4 @@
-using AntSK.Domain.Model.Enum;
+using AntSK.Domain.Domain.Model.Enum;
 using SqlSugar;
 using System.ComponentModel.DataAnnotations;
 

src/AntSK.Domain/Repositories/Setting/Dic/Dics.cs

@@ -0,0 +1,16 @@
+using AntSK.Domain.Domain.Model.Enum;
+using SqlSugar;
+using System.ComponentModel.DataAnnotations;
+
+namespace AntSK.Domain.Repositories
+{
+    [SugarTable("Dics")]
+    public partial class Dics
+    {
+        [SugarColumn(IsPrimaryKey = true)]
+        public string Id { get; set; }       
+        public string Type { get; set; }
+        public string Key { get; set; }
+        public string Value { get; set; }
+    }
+}