Files
Enterprise-Knowledge-Base/internal/models/chat/ollama.go
T
wizardchen a4b255a456 feat: implement final_answer tool and enhance agent duration tracking
- Introduced the final_answer tool to ensure agents submit their complete responses as the last action, improving response accuracy and consistency.
- Updated the agent engine to log detailed information about tool calls and responses, including the total duration of agent execution.
- Enhanced the chat message model to include agent_duration_ms, tracking the total execution time from query start to answer delivery.
- Implemented JSON field extraction for streaming responses, allowing for more efficient handling of tool call outputs.

These changes significantly improve the agent's response handling and ensure that final answers are consistently delivered, enhancing overall user experience.
2026-03-09 11:46:56 +08:00

363 lines
9.6 KiB
Go

package chat
import (
"context"
"encoding/json"
"fmt"
"strconv"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/models/utils/ollama"
"github.com/Tencent/WeKnora/internal/types"
ollamaapi "github.com/ollama/ollama/api"
)
// OllamaChat 实现了基于 Ollama 的聊天
type OllamaChat struct {
modelName string
modelID string
ollamaService *ollama.OllamaService
}
// NewOllamaChat 创建 Ollama 聊天实例
func NewOllamaChat(config *ChatConfig, ollamaService *ollama.OllamaService) (*OllamaChat, error) {
return &OllamaChat{
modelName: config.ModelName,
modelID: config.ModelID,
ollamaService: ollamaService,
}, nil
}
// convertMessages 转换消息格式为Ollama API格式
func (c *OllamaChat) convertMessages(messages []Message) []ollamaapi.Message {
ollamaMessages := make([]ollamaapi.Message, 0, len(messages))
for _, msg := range messages {
msgOllama := ollamaapi.Message{
Role: msg.Role,
Content: msg.Content,
ToolCalls: c.toolCallFrom(msg.ToolCalls),
}
if msg.Role == "tool" {
msgOllama.ToolName = msg.Name
}
ollamaMessages = append(ollamaMessages, msgOllama)
}
return ollamaMessages
}
// buildChatRequest 构建聊天请求参数
func (c *OllamaChat) buildChatRequest(messages []Message, opts *ChatOptions, isStream bool) *ollamaapi.ChatRequest {
// 设置流式标志
streamFlag := isStream
// 构建请求参数
chatReq := &ollamaapi.ChatRequest{
Model: c.modelName,
Messages: c.convertMessages(messages),
Stream: &streamFlag,
Options: make(map[string]interface{}),
}
// 添加可选参数
if opts != nil {
if opts.Temperature > 0 {
chatReq.Options["temperature"] = opts.Temperature
}
if opts.TopP > 0 {
chatReq.Options["top_p"] = opts.TopP
}
if opts.MaxTokens > 0 {
chatReq.Options["num_predict"] = opts.MaxTokens
}
if opts.Thinking != nil {
chatReq.Think = &ollamaapi.ThinkValue{
Value: *opts.Thinking,
}
}
if len(opts.Format) > 0 {
chatReq.Format = opts.Format
}
if len(opts.Tools) > 0 {
chatReq.Tools = c.toolFrom(opts.Tools)
}
}
return chatReq
}
// Chat 进行非流式聊天
func (c *OllamaChat) Chat(ctx context.Context, messages []Message, opts *ChatOptions) (*types.ChatResponse, error) {
// 确保模型可用
if err := c.ensureModelAvailable(ctx); err != nil {
return nil, err
}
// 构建请求参数
chatReq := c.buildChatRequest(messages, opts, false)
// 记录请求日志
logger.GetLogger(ctx).Infof("发送聊天请求到模型 %s", c.modelName)
var responseContent string
var toolCalls []types.LLMToolCall
var promptTokens, completionTokens int
// 使用 Ollama 客户端发送请求
err := c.ollamaService.Chat(ctx, chatReq, func(resp ollamaapi.ChatResponse) error {
responseContent = resp.Message.Content
// 当 Content 为空但 Thinking 有内容时(如推理模型未正确配置 thinking 参数),使用 Thinking 作为兜底
if responseContent == "" && resp.Message.Thinking != "" {
responseContent = resp.Message.Thinking
}
toolCalls = c.toolCallTo(resp.Message.ToolCalls)
// 获取token计数
if resp.EvalCount > 0 {
promptTokens = resp.PromptEvalCount
completionTokens = resp.EvalCount - promptTokens
}
return nil
})
if err != nil {
return nil, fmt.Errorf("聊天请求失败: %w", err)
}
// 构建响应
return &types.ChatResponse{
Content: responseContent,
ToolCalls: toolCalls,
Usage: struct {
PromptTokens int `json:"prompt_tokens"`
CompletionTokens int `json:"completion_tokens"`
TotalTokens int `json:"total_tokens"`
}{
PromptTokens: promptTokens,
CompletionTokens: completionTokens,
TotalTokens: promptTokens + completionTokens,
},
}, nil
}
// ChatStream 进行流式聊天
func (c *OllamaChat) ChatStream(
ctx context.Context,
messages []Message,
opts *ChatOptions,
) (<-chan types.StreamResponse, error) {
// 确保模型可用
if err := c.ensureModelAvailable(ctx); err != nil {
return nil, err
}
// 构建请求参数
chatReq := c.buildChatRequest(messages, opts, true)
// 记录请求日志
logger.GetLogger(ctx).Infof("发送流式聊天请求到模型 %s", c.modelName)
// 创建流式响应通道
streamChan := make(chan types.StreamResponse)
// 启动goroutine处理流式响应
go func() {
defer close(streamChan)
hasThinking := false
err := c.ollamaService.Chat(ctx, chatReq, func(resp ollamaapi.ChatResponse) error {
// 发送思考内容(支持 Qwen3、DeepSeek 等推理模型)
if resp.Message.Thinking != "" {
hasThinking = true
streamChan <- types.StreamResponse{
ResponseType: types.ResponseTypeThinking,
Content: resp.Message.Thinking,
Done: false,
}
}
if resp.Message.Content != "" {
// 思考阶段结束后,发送思考完成事件
if hasThinking {
streamChan <- types.StreamResponse{
ResponseType: types.ResponseTypeThinking,
Done: true,
}
hasThinking = false
}
streamChan <- types.StreamResponse{
ResponseType: types.ResponseTypeAnswer,
Content: resp.Message.Content,
Done: false,
}
}
if len(resp.Message.ToolCalls) > 0 {
streamChan <- types.StreamResponse{
ResponseType: types.ResponseTypeToolCall,
ToolCalls: c.toolCallTo(resp.Message.ToolCalls),
Done: false,
}
// Extract and stream content from special tools (complete, not incremental)
for _, tc := range resp.Message.ToolCalls {
switch tc.Function.Name {
case "final_answer":
if answer, ok := tc.Function.Arguments["answer"].(string); ok && answer != "" {
streamChan <- types.StreamResponse{
ResponseType: types.ResponseTypeAnswer,
Content: answer,
Done: false,
Data: map[string]interface{}{
"source": "final_answer_tool",
},
}
}
case "thinking":
if thought, ok := tc.Function.Arguments["thought"].(string); ok && thought != "" {
streamChan <- types.StreamResponse{
ResponseType: types.ResponseTypeThinking,
Content: thought,
Done: false,
Data: map[string]interface{}{
"source": "thinking_tool",
"tool_call_id": tooli2s(tc.Function.Index),
},
}
}
}
}
}
if resp.Done {
streamChan <- types.StreamResponse{
ResponseType: types.ResponseTypeAnswer,
Done: true,
}
}
return nil
})
if err != nil {
logger.GetLogger(ctx).Errorf("流式聊天请求失败: %v", err)
// 发送错误响应
streamChan <- types.StreamResponse{
ResponseType: types.ResponseTypeError,
Content: err.Error(),
Done: true,
}
}
}()
return streamChan, nil
}
// 确保模型可用
func (c *OllamaChat) ensureModelAvailable(ctx context.Context) error {
logger.GetLogger(ctx).Infof("确保模型 %s 可用", c.modelName)
return c.ollamaService.EnsureModelAvailable(ctx, c.modelName)
}
// GetModelName 获取模型名称
func (c *OllamaChat) GetModelName() string {
return c.modelName
}
// GetModelID 获取模型ID
func (c *OllamaChat) GetModelID() string {
return c.modelID
}
// toolFrom 将本模块的 Tool 转换为 Ollama 的 Tool
func (c *OllamaChat) toolFrom(tools []Tool) ollamaapi.Tools {
if len(tools) == 0 {
return nil
}
ollamaTools := make(ollamaapi.Tools, 0, len(tools))
for _, tool := range tools {
function := ollamaapi.ToolFunction{
Name: tool.Function.Name,
Description: tool.Function.Description,
}
if len(tool.Function.Parameters) > 0 {
_ = json.Unmarshal(tool.Function.Parameters, &function.Parameters)
}
ollamaTools = append(ollamaTools, ollamaapi.Tool{
Type: tool.Type,
Function: function,
})
}
return ollamaTools
}
// toolTo 将 Ollama 的 Tool 转换为本模块的 Tool
func (c *OllamaChat) toolTo(ollamaTools ollamaapi.Tools) []Tool {
if len(ollamaTools) == 0 {
return nil
}
tools := make([]Tool, 0, len(ollamaTools))
for _, tool := range ollamaTools {
paramsBytes, _ := json.Marshal(tool.Function.Parameters)
tools = append(tools, Tool{
Type: tool.Type,
Function: FunctionDef{
Name: tool.Function.Name,
Description: tool.Function.Description,
Parameters: paramsBytes,
},
})
}
return tools
}
// toolCallFrom 将本模块的 ToolCall 转换为 Ollama 的 ToolCall
func (c *OllamaChat) toolCallFrom(toolCalls []ToolCall) []ollamaapi.ToolCall {
if len(toolCalls) == 0 {
return nil
}
ollamaToolCalls := make([]ollamaapi.ToolCall, 0, len(toolCalls))
for _, tc := range toolCalls {
var args map[string]interface{}
if tc.Function.Arguments != "" {
_ = json.Unmarshal([]byte(tc.Function.Arguments), &args)
}
ollamaToolCalls = append(ollamaToolCalls, ollamaapi.ToolCall{
Function: ollamaapi.ToolCallFunction{
Index: tools2i(tc.ID),
Name: tc.Function.Name,
Arguments: args,
},
})
}
return ollamaToolCalls
}
// toolCallTo 将 Ollama 的 ToolCall 转换为本模块的 ToolCall
func (c *OllamaChat) toolCallTo(ollamaToolCalls []ollamaapi.ToolCall) []types.LLMToolCall {
if len(ollamaToolCalls) == 0 {
return nil
}
toolCalls := make([]types.LLMToolCall, 0, len(ollamaToolCalls))
for _, tc := range ollamaToolCalls {
argsBytes, _ := json.Marshal(tc.Function.Arguments)
toolCalls = append(toolCalls, types.LLMToolCall{
ID: tooli2s(tc.Function.Index),
Type: "function",
Function: types.FunctionCall{
Name: tc.Function.Name,
Arguments: string(argsBytes),
},
})
}
return toolCalls
}
func tooli2s(i int) string {
return strconv.Itoa(i)
}
func tools2i(s string) int {
i, _ := strconv.Atoi(s)
return i
}