sascha
/
Notes
mirror of https://github.com/TriliumNext/Notes
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix(llm): reduce the use of "any" in the tool_calling_stage and update prompt for tool calling

pull/2082/head
perf3ct 2025-05-29 21:15:05 +07:00
parent ba59d6b3c1
commit 87859aec1c
No known key found for this signature in database
GPG Key ID: 569C4EEC436F5232
2 changed files with 84 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
apps/server/src/assets/llm/prompts/providers/ollama_tool_prompt.md
Unescape Escape View File

@ -33,14 +33,17 @@ When responding to queries:
6. For specific questions, provide detailed information from the user's notes that directly addresses the question
7. Always prioritize information from the user's notes over your own knowledge, as the user's notes are likely more up-to-date and personally relevant
When using tools, follow these best practices:
1. If a tool returns an error or no results, DO NOT give up immediately
2. Instead, try different parameters that might yield better results:
- For search tools: Try broader search terms, fewer filters, or synonyms
- For note navigation: Try parent or sibling notes if a specific note isn't found
- For content analysis: Try rephrasing or generalizing the query
3. When searching for information, start with specific search terms but be prepared to broaden your search if no results are found
4. If multiple attempts with different parameters still yield no results, clearly explain to the user that the information they're looking for might not be in their notes
5. When suggesting alternatives, be explicit about what parameters you've tried and what you're changing
6. Remember that empty results from tools don't mean the user's request can't be fulfilled - it often means the parameters need adjustment
CRITICAL INSTRUCTIONS FOR TOOL USAGE:
1. YOU MUST TRY MULTIPLE TOOLS AND SEARCH VARIATIONS before concluding information isn't available
2. ALWAYS PERFORM AT LEAST 3 DIFFERENT SEARCHES with different parameters before giving up on finding information
3. If a search returns no results, IMMEDIATELY TRY ANOTHER SEARCH with different parameters:
- Use broader terms: If "Kubernetes deployment" fails, try just "Kubernetes" or "container orchestration"
- Try synonyms: If "meeting notes" fails, try "conference", "discussion", or "conversation"
- Remove specific qualifiers: If "quarterly financial report 2024" fails, try just "financial report"
- Try semantic variations: If keyword_search fails, use vector_search which finds conceptually related content
4. CHAIN TOOLS TOGETHER: Use the results of one tool to inform parameters for the next tool
5. NEVER respond with "there are no notes about X" until you've tried at least 3 different search variations
6. DO NOT ask the user what to do next when searches fail - AUTOMATICALLY try different approaches
7. ALWAYS EXPLAIN what you're doing: "I didn't find results for X, so I'm now searching for Y instead"
8. If all reasonable search variations fail (minimum 3 attempts), THEN you may inform the user that the information might not be in their notes
```

89
apps/server/src/services/llm/pipeline/stages/tool_calling_stage.ts
Unescape Escape View File

@ -6,6 +6,25 @@ import toolRegistry from '../../tools/tool_registry.js';
import chatStorageService from '../../chat_storage_service.js';
import aiServiceManager from '../../ai_service_manager.js';
// Type definitions for tools and validation results
interface ToolInterface {
execute: (args: Record<string, unknown>) => Promise<unknown>;
[key: string]: unknown;
}
interface ToolValidationResult {
toolCall: {
id?: string;
function: {
name: string;
arguments: string | Record<string, unknown>;
};
};
valid: boolean;
tool: ToolInterface | null;
error: string | null;
}
/**
* Pipeline stage for handling LLM tool calling
* This stage is responsible for:
@ -50,12 +69,23 @@ export class ToolCallingStage extends BasePipelineStage<ToolExecutionInput, { re
}
// Check if the registry has any tools
const availableTools = toolRegistry.getAllTools();
const availableTools: ToolInterface[] = toolRegistry.getAllTools() as unknown as ToolInterface[];
log.info(`Available tools in registry: ${availableTools.length}`);
// Log available tools for debugging
if (availableTools.length > 0) {
const availableToolNames = availableTools.map(t => t.definition.function.name).join(', ');
const availableToolNames = availableTools.map(t => {
// Safely access the name property using type narrowing
if (t && typeof t === 'object' && 'definition' in t &&
t.definition && typeof t.definition === 'object' &&
'function' in t.definition && t.definition.function &&
typeof t.definition.function === 'object' &&
'name' in t.definition.function &&
typeof t.definition.function.name === 'string') {
return t.definition.function.name;
}
return 'unknown';
}).join(', ');
log.info(`Available tools: ${availableToolNames}`);
}
@ -66,7 +96,8 @@ export class ToolCallingStage extends BasePipelineStage<ToolExecutionInput, { re
log.info('Attempting to initialize tools as recovery step');
// Tools are already initialized in the AIServiceManager constructor
// No need to initialize them again
log.info(`After recovery initialization: ${toolRegistry.getAllTools().length} tools available`);
const toolCount = toolRegistry.getAllTools().length;
log.info(`After recovery initialization: ${toolCount} tools available`);
} catch (error: unknown) {
const errorMessage = error instanceof Error ? error.message : String(error);
log.error(`Failed to initialize tools in recovery step: ${errorMessage}`);
@ -89,9 +120,9 @@ export class ToolCallingStage extends BasePipelineStage<ToolExecutionInput, { re
const executionStartTime = Date.now();
// First validate all tools before executing them
// First validate all tools before execution
log.info(`Validating ${response.tool_calls?.length || 0} tools before execution`);
const validationResults = await Promise.all((response.tool_calls || []).map(async (toolCall) => {
const validationResults: ToolValidationResult[] = await Promise.all((response.tool_calls || []).map(async (toolCall) => {
try {
// Get the tool from registry
const tool = toolRegistry.getTool(toolCall.function.name);
@ -107,7 +138,8 @@ export class ToolCallingStage extends BasePipelineStage<ToolExecutionInput, { re
}
// Validate the tool before execution
const isToolValid = await this.validateToolBeforeExecution(tool, toolCall.function.name);
// Use unknown as an intermediate step for type conversion
const isToolValid = await this.validateToolBeforeExecution(tool as unknown as ToolInterface, toolCall.function.name);
if (!isToolValid) {
throw new Error(`Tool '${toolCall.function.name}' failed validation before execution`);
}
@ -115,15 +147,16 @@ export class ToolCallingStage extends BasePipelineStage<ToolExecutionInput, { re
return {
toolCall,
valid: true,
tool,
tool: tool as unknown as ToolInterface,
error: null
};
} catch (error: any) {
} catch (error: unknown) {
const errorMessage = error instanceof Error ? error.message : String(error);
return {
toolCall,
valid: false,
tool: null,
error: error.message || String(error)
error: errorMessage
};
}
}));
@ -150,7 +183,7 @@ export class ToolCallingStage extends BasePipelineStage<ToolExecutionInput, { re
log.info(`Tool validated successfully: ${toolCall.function.name}`);
// Parse arguments (handle both string and object formats)
let args;
let args: Record<string, unknown>;
// At this stage, arguments should already be processed by the provider-specific service
// But we still need to handle different formats just in case
if (typeof toolCall.function.arguments === 'string') {
@ -158,7 +191,7 @@ export class ToolCallingStage extends BasePipelineStage<ToolExecutionInput, { re
try {
// Try to parse as JSON first
args = JSON.parse(toolCall.function.arguments);
args = JSON.parse(toolCall.function.arguments) as Record<string, unknown>;
log.info(`Parsed JSON arguments: ${Object.keys(args).join(', ')}`);
} catch (e: unknown) {
// If it's not valid JSON, try to check if it's a stringified object with quotes
@ -169,25 +202,26 @@ export class ToolCallingStage extends BasePipelineStage<ToolExecutionInput, { re
// Try to clean it up
try {
const cleaned = toolCall.function.arguments
.replace(/^['"]|['"]$/g, '') // Remove surrounding quotes
.replace(/^['"]/g, '') // Remove surrounding quotes
.replace(/['"]$/g, '') // Remove surrounding quotes
.replace(/\\"/g, '"') // Replace escaped quotes
.replace(/([{,])\s*'([^']+)'\s*:/g, '$1"$2":') // Replace single quotes around property names
.replace(/([{,])\s*(\w+)\s*:/g, '$1"$2":'); // Add quotes around unquoted property names
log.info(`Cleaned argument string: ${cleaned}`);
args = JSON.parse(cleaned);
args = JSON.parse(cleaned) as Record<string, unknown>;
log.info(`Successfully parsed cleaned arguments: ${Object.keys(args).join(', ')}`);
} catch (cleanError: unknown) {
// If all parsing fails, treat it as a text argument
const cleanErrorMessage = cleanError instanceof Error ? cleanError.message : String(cleanError);
log.info(`Failed to parse cleaned arguments: ${cleanErrorMessage}`);
args = { text: toolCall.function.arguments };
log.info(`Using text argument: ${args.text.substring(0, 50)}...`);
log.info(`Using text argument: ${(args.text as string).substring(0, 50)}...`);
}
}
} else {
// Arguments are already an object
args = toolCall.function.arguments;
args = toolCall.function.arguments as Record<string, unknown>;
log.info(`Using object arguments with keys: ${Object.keys(args).join(', ')}`);
}
@ -423,10 +457,29 @@ export class ToolCallingStage extends BasePipelineStage<ToolExecutionInput, { re
// Add a system message with hints for empty results
if (hasEmptyResults && needsFollowUp) {
log.info('Adding system hint for empty tool results to encourage parameter adjustment');
log.info('Adding system message requiring the LLM to run additional tools with different parameters');
// Build a more directive message based on which tools were empty
const emptyToolNames = toolResultMessages
.filter(msg => this.isEmptyToolResult(msg.content, msg.name || ''))
.map(msg => msg.name);
let directiveMessage = `YOU MUST NOT GIVE UP AFTER A SINGLE EMPTY SEARCH RESULT. `;
if (emptyToolNames.includes('search_notes') || emptyToolNames.includes('vector_search')) {
directiveMessage += `IMMEDIATELY RUN ANOTHER SEARCH TOOL with broader search terms, alternative keywords, or related concepts. `;
directiveMessage += `Try synonyms, more general terms, or related topics. `;
}
if (emptyToolNames.includes('keyword_search')) {
directiveMessage += `IMMEDIATELY TRY VECTOR_SEARCH INSTEAD as it might find semantic matches where keyword search failed. `;
}
directiveMessage += `DO NOT ask the user what to do next or if they want general information. CONTINUE SEARCHING with different parameters.`;
updatedMessages.push({
role: 'system',
content: `The previous tool execution(s) completed but returned no useful results. Consider trying different parameters for better results. For search tools, try broader search terms, fewer filters, or synonyms. For navigation tools, try exploring parent or sibling notes.`
content: directiveMessage
});
}
@ -517,7 +570,7 @@ export class ToolCallingStage extends BasePipelineStage<ToolExecutionInput, { re
* @param tool The tool to validate
* @param toolName The name of the tool
*/
private async validateToolBeforeExecution(tool: { execute: (args: Record<string, unknown>) => Promise<unknown> }, toolName: string): Promise<boolean> {
private async validateToolBeforeExecution(tool: ToolInterface, toolName: string): Promise<boolean> {
try {
if (!tool) {
log.error(`Tool '${toolName}' not found or failed validation`);