@prmichaelsen/remember-mcp 2.6.3 → 2.6.5

package/CHANGELOG.md

@@ -5,6 +5,52 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.6.5] - 2026-02-16
+
+### 🐛 Fixed
+
+- **CRITICAL: Fixed Schema Property Mismatch in fetchMemoryWithAllProperties**
+  - `ALL_MEMORY_PROPERTIES` constant had `trust_level` but schema has `trust`
+  - Caused publish operations to fail with schema validation error
+  - Fixed property name to match actual schema: `trust_level` → `trust`
+  - Added missing `confidence` property to the list
+  - Publish functionality now works correctly
+
+### 🎯 Impact
+
+- **Fixes**: Publishing memories to shared spaces now works
+- **Unblocks**: Core publish/space functionality restored
+- **Note**: This was introduced in v2.6.3 when creating the utility function
+
+---
+
+## [2.6.4] - 2026-02-16
+
+### 🔧 Improved
+
+- **Enhanced Tool Descriptions to Prevent Over-Filtering**
+  - Added explicit warnings to all search/query tools about content type filtering
+  - Agents now instructed to NOT add content_type filters unless explicitly requested by user
+  - Prevents missed results from over-filtering by content type
+  - Improves search quality and user experience
+
+### 📝 Changed
+
+- Updated `remember_search_memory` description with content type filtering guidance
+- Updated `remember_query_memory` description with content type filtering guidance
+- Updated `remember_search_space` description with content type filtering guidance
+- Updated `remember_query_space` description with content type filtering guidance
+- Added ✅ CORRECT and ❌ WRONG examples to clarify when to filter
+
+### 🎯 Impact
+
+- **Better Search Results**: No more over-filtering by content type
+- **More Relevant Memories**: All types included unless user specifies
+- **Clearer Agent Behavior**: Explicit guidance on when to use filters
+- **Improved UX**: Users get comprehensive results by default
+
+---
+
 ## [2.6.3] - 2026-02-16
 
 ### 🐛 Fixed

package/agent/tasks/task-64-prevent-implicit-content-type-filtering.md

@@ -0,0 +1,289 @@
+# Task 64: Update Search/Query Tool Descriptions - No Implicit Content Type Filtering
+
+**Milestone**: M12 (Bug Fixes / UX Improvements)
+**Estimated Time**: 1 hour
+**Dependencies**: None
+**Status**: Not Started
+**Priority**: High
+
+---
+
+## Objective
+
+Update all search and query tool descriptions to explicitly instruct agents to NEVER add content_type filters unless the user explicitly requests filtering by content type. This prevents agents from over-filtering results and missing relevant memories.
+
+---
+
+## Context
+
+**Current Problem**:
+Agents are adding `content_type` filters to search queries even when users don't request them. This causes:
+- Missed results (memories with different content types excluded)
+- Poor search experience (user searches for "hiking" but agent filters to only "note" type)
+- Confusion (user doesn't understand why results are limited)
+
+**Example Bad Behavior**:
+```
+User: "Search for memories about hiking"
+Agent: remember_search_memory({ query: "hiking", content_type: "note" })
+Result: Misses "event", "activity", "location" memories about hiking
+```
+
+**Expected Behavior**:
+```
+User: "Search for memories about hiking"
+Agent: remember_search_memory({ query: "hiking" })
+Result: Returns ALL memories about hiking regardless of type
+```
+
+**When to Filter**:
+```
+User: "Search for note memories about hiking"
+Agent: remember_search_memory({ query: "hiking", content_type: "note" })
+Result: Correctly filters to only notes
+```
+
+---
+
+## Steps
+
+### 1. Update remember_search_memory Description
+
+Add explicit instruction to tool description:
+
+```typescript
+// src/tools/search-memory.ts
+
+export const searchMemoryTool: Tool = {
+  name: 'remember_search_memory',
+  description: `Search your personal memories using hybrid search (semantic + keyword).
+
+⚠️ IMPORTANT: Do NOT add content_type filter unless the user explicitly requests filtering by type.
+- ✅ CORRECT: User says "search for hiking" → { query: "hiking" }
+- ❌ WRONG: User says "search for hiking" → { query: "hiking", content_type: "note" }
+- ✅ CORRECT: User says "search for note memories about hiking" → { query: "hiking", content_type: "note" }
+
+Let the search algorithm find ALL relevant memories regardless of type unless explicitly requested.`,
+  // ... rest of tool definition
+};
+```
+
+### 2. Update remember_query_memory Description
+
+Add same instruction:
+
+```typescript
+// src/tools/query-memory.ts
+
+export const queryMemoryTool: Tool = {
+  name: 'remember_query_memory',
+  description: `Query your personal memories using natural language (RAG-optimized).
+
+⚠️ IMPORTANT: Do NOT add content_type filter unless the user explicitly requests filtering by type.
+- ✅ CORRECT: User says "what do I know about hiking?" → { query: "hiking" }
+- ❌ WRONG: User says "what do I know about hiking?" → { query: "hiking", content_type: "note" }
+- ✅ CORRECT: User says "what notes do I have about hiking?" → { query: "hiking", content_type: "note" }
+
+Let the query algorithm find ALL relevant memories regardless of type unless explicitly requested.`,
+  // ... rest of tool definition
+};
+```
+
+### 3. Update remember_search_space Description
+
+Add same instruction:
+
+```typescript
+// src/tools/search-space.ts
+
+export const searchSpaceTool: Tool = {
+  name: 'remember_search_space',
+  description: `Search shared spaces for published memories.
+
+⚠️ IMPORTANT: Do NOT add content_type filter unless the user explicitly requests filtering by type.
+- ✅ CORRECT: User says "search The Void for hiking" → { spaces: ["the_void"], query: "hiking" }
+- ❌ WRONG: User says "search The Void for hiking" → { spaces: ["the_void"], query: "hiking", content_type: "note" }
+- ✅ CORRECT: User says "search The Void for note memories about hiking" → { spaces: ["the_void"], query: "hiking", content_type: "note" }
+
+Let the search algorithm find ALL relevant memories regardless of type unless explicitly requested.`,
+  // ... rest of tool definition
+};
+```
+
+### 4. Update remember_query_space Description
+
+Add same instruction:
+
+```typescript
+// src/tools/query-space.ts
+
+export const querySpaceTool: Tool = {
+  name: 'remember_query_space',
+  description: `Query shared spaces using natural language (RAG-optimized).
+
+⚠️ IMPORTANT: Do NOT add content_type filter unless the user explicitly requests filtering by type.
+- ✅ CORRECT: User says "what's in The Void about hiking?" → { spaces: ["the_void"], query: "hiking" }
+- ❌ WRONG: User says "what's in The Void about hiking?" → { spaces: ["the_void"], query: "hiking", content_type: "note" }
+- ✅ CORRECT: User says "what notes are in The Void about hiking?" → { spaces: ["the_void"], query: "hiking", content_type: "note" }
+
+Let the query algorithm find ALL relevant memories regardless of type unless explicitly requested.`,
+  // ... rest of tool definition
+};
+```
+
+### 5. Update remember_search_relationship Description (Optional)
+
+Consider adding similar guidance:
+
+```typescript
+// src/tools/search-relationship.ts
+
+export const searchRelationshipTool: Tool = {
+  name: 'remember_search_relationship',
+  description: `Search for relationships between memories.
+
+⚠️ IMPORTANT: Do NOT add relationship_type filter unless the user explicitly requests filtering by type.
+- ✅ CORRECT: User says "find relationships about hiking" → { query: "hiking" }
+- ❌ WRONG: User says "find relationships about hiking" → { query: "hiking", relationship_type: "inspired_by" }
+
+Let the search algorithm find ALL relevant relationships regardless of type unless explicitly requested.`,
+  // ... rest of tool definition
+};
+```
+
+### 6. Test Agent Behavior
+
+Manual testing to verify agents follow instructions:
+
+```bash
+# Test 1: Generic search (should NOT add content_type)
+User: "Search for memories about hiking"
+Expected: { query: "hiking" }
+Wrong: { query: "hiking", content_type: "note" }
+
+# Test 2: Explicit type request (should add content_type)
+User: "Search for note memories about hiking"
+Expected: { query: "hiking", content_type: "note" }
+
+# Test 3: Space search (should NOT add content_type)
+User: "Search The Void for hiking trails"
+Expected: { spaces: ["the_void"], query: "hiking trails" }
+Wrong: { spaces: ["the_void"], query: "hiking trails", content_type: "location" }
+
+# Test 4: Explicit type in space (should add content_type)
+User: "Search The Void for location memories about hiking"
+Expected: { spaces: ["the_void"], query: "hiking", content_type: "location" }
+```
+
+---
+
+## Verification
+
+- [ ] `remember_search_memory` description includes "Do NOT add content_type filter" warning
+- [ ] `remember_query_memory` description includes same warning
+- [ ] `remember_search_space` description includes same warning
+- [ ] `remember_query_space` description includes same warning
+- [ ] Each tool has ✅ CORRECT and ❌ WRONG examples
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+- [ ] Manual test: Agent doesn't add content_type for generic searches
+- [ ] Manual test: Agent adds content_type when explicitly requested
+
+---
+
+## Expected Output
+
+**Tool Descriptions Before**:
+```
+Search your personal memories using hybrid search (semantic + keyword).
+```
+
+**Tool Descriptions After**:
+```
+Search your personal memories using hybrid search (semantic + keyword).
+
+⚠️ IMPORTANT: Do NOT add content_type filter unless the user explicitly requests filtering by type.
+- ✅ CORRECT: User says "search for hiking" → { query: "hiking" }
+- ❌ WRONG: User says "search for hiking" → { query: "hiking", content_type: "note" }
+- ✅ CORRECT: User says "search for note memories about hiking" → { query: "hiking", content_type: "note" }
+
+Let the search algorithm find ALL relevant memories regardless of type unless explicitly requested.
+```
+
+---
+
+## Impact Analysis
+
+**Severity**: High (affects search quality and user experience)
+
+**Affected Tools**: 4-5 tools
+- `remember_search_memory`
+- `remember_query_memory`
+- `remember_search_space`
+- `remember_query_space`
+- `remember_search_relationship` (optional)
+
+**User Impact**:
+- Better search results (no over-filtering)
+- More relevant memories returned
+- Clearer agent behavior
+- Improved user experience
+
+**Agent Impact**:
+- Clear guidance on when to filter
+- Reduces confusion about content_type parameter
+- Better alignment with user intent
+
+---
+
+## Common Issues and Solutions
+
+### Issue 1: Agent still adds content_type filters
+
+**Cause**: Agent's base model behavior overrides tool description
+**Solution**: Make warning more prominent with ⚠️ emoji and examples
+
+### Issue 2: Agent never adds content_type even when requested
+
+**Cause**: Warning too strong, agent avoids parameter entirely
+**Solution**: Include ✅ CORRECT examples showing when to use it
+
+### Issue 3: Unclear when "explicit request" means
+
+**Cause**: Ambiguous language in user query
+**Solution**: Provide clear examples in tool description
+
+---
+
+## Resources
+
+- [Tool Descriptions Best Practices](https://modelcontextprotocol.io/docs/concepts/tools)
+- [remember_search_memory Tool](../src/tools/search-memory.ts)
+- [remember_query_memory Tool](../src/tools/query-memory.ts)
+- [remember_search_space Tool](../src/tools/search-space.ts)
+- [remember_query_space Tool](../src/tools/query-space.ts)
+
+---
+
+## Notes
+
+- This is a documentation-only change (no code logic changes)
+- Affects agent behavior through tool description guidance
+- May need iteration based on observed agent behavior
+- Consider adding to system prompt if tool descriptions aren't sufficient
+- Could be extended to other optional filter parameters (tags, weight, etc.)
+
+---
+
+## Related Tasks
+
+- **Task 63**: Fix empty published memories (completed)
+- **Task 62**: Fix confirmation response storage (pending)
+- **Task 58**: Add comment unit tests (pending)
+- **Task 59**: Update documentation (pending)
+
+---
+
+**Status**: Not Started
+**Recommendation**: Implement after Task 62 to improve search UX
+**Priority**: High - Directly impacts user experience and search quality

package/dist/server-factory.js

@@ -574,7 +574,9 @@ var ALL_MEMORY_PROPERTIES = [
   "tags",
   "weight",
   "base_weight",
-  "trust_level",
+  "trust",
+  // ✅ Fixed: was 'trust_level', schema has 'trust'
+  "confidence",
   "context",
   "location",
   "relationships",
@@ -1570,6 +1572,11 @@ var searchMemoryTool = {
   - "Show me notes from last week" \u2192 returns notes + any relationships created that week
   
   **AGENT GUIDANCE**:
+  - \u26A0\uFE0F **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add filters.types unless the user explicitly requests filtering by content type.
+    * \u2705 CORRECT: User says "search for hiking" \u2192 { query: "hiking" }
+    * \u274C WRONG: User says "search for hiking" \u2192 { query: "hiking", filters: { types: ["note"] } }
+    * \u2705 CORRECT: User says "search for note memories about hiking" \u2192 { query: "hiking", filters: { types: ["note"] } }
+    * Let the search algorithm find ALL relevant memories regardless of type unless explicitly requested.
   - If search results are too narrow or miss relevant content, try remember_query_memory instead - it uses pure semantic search which is better for broader, concept-based queries. You can inform the user: "I didn't find what you're looking for with keyword search. Let me try a broader semantic search using the query tool."
   - **CRITICAL**: If no results are returned, DO NOT make up or fabricate memories. Only report what was actually found. Tell the user honestly that no matching memories were found and suggest they:
     * Create a new memory with the information they're looking for
@@ -2140,6 +2147,11 @@ var queryMemoryTool = {
   - "What are my project goals?"
   
   **AGENT GUIDANCE**:
+  - \u26A0\uFE0F **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add filters.types unless the user explicitly requests filtering by content type.
+    * \u2705 CORRECT: User says "what do I know about hiking?" \u2192 { query: "hiking" }
+    * \u274C WRONG: User says "what do I know about hiking?" \u2192 { query: "hiking", filters: { types: ["note"] } }
+    * \u2705 CORRECT: User says "what notes do I have about hiking?" \u2192 { query: "hiking", filters: { types: ["note"] } }
+    * Let the query algorithm find ALL relevant memories regardless of type unless explicitly requested.
   - If query results are too broad or include irrelevant content, try remember_search_memory instead - it uses hybrid search with keyword matching which is better for precise, specific searches. You can inform the user: "The results were too broad. Let me try a more precise keyword search using the search tool."
   - **CRITICAL**: If no results are returned, DO NOT make up or fabricate memories. Only report what was actually found. Tell the user honestly that no matching memories were found and suggest they:
     * Create a new memory with the information they're looking for
@@ -4223,7 +4235,14 @@ import { Filters as Filters3 } from "weaviate-client";
 init_space_memory();
 var searchSpaceTool = {
   name: "remember_search_space",
-  description: "Search one or more shared spaces to discover thoughts, ideas, and memories. By default, excludes comments to keep discovery clean. Set include_comments: true to include threaded discussions. Can search multiple spaces in a single query.",
+  description: `Search one or more shared spaces to discover thoughts, ideas, and memories. By default, excludes comments to keep discovery clean. Set include_comments: true to include threaded discussions. Can search multiple spaces in a single query.
+
+\u26A0\uFE0F **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add content_type filter unless the user explicitly requests filtering by type.
+- \u2705 CORRECT: User says "search The Void for hiking" \u2192 { spaces: ["the_void"], query: "hiking" }
+- \u274C WRONG: User says "search The Void for hiking" \u2192 { spaces: ["the_void"], query: "hiking", content_type: "note" }
+- \u2705 CORRECT: User says "search The Void for note memories about hiking" \u2192 { spaces: ["the_void"], query: "hiking", content_type: "note" }
+
+Let the search algorithm find ALL relevant memories regardless of type unless explicitly requested.`,
   inputSchema: {
     type: "object",
     properties: {
@@ -4382,7 +4401,14 @@ import { Filters as Filters4 } from "weaviate-client";
 init_space_memory();
 var querySpaceTool = {
   name: "remember_query_space",
-  description: "Ask natural language questions about memories in shared spaces. By default, excludes comments to focus on original content. Set include_comments: true to include discussions in answers.",
+  description: `Ask natural language questions about memories in shared spaces. By default, excludes comments to focus on original content. Set include_comments: true to include discussions in answers.
+
+\u26A0\uFE0F **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add content_type filter unless the user explicitly requests filtering by type.
+- \u2705 CORRECT: User says "what's in The Void about hiking?" \u2192 { spaces: ["the_void"], question: "hiking" }
+- \u274C WRONG: User says "what's in The Void about hiking?" \u2192 { spaces: ["the_void"], question: "hiking", content_type: "note" }
+- \u2705 CORRECT: User says "what notes are in The Void about hiking?" \u2192 { spaces: ["the_void"], question: "hiking", content_type: "note" }
+
+Let the query algorithm find ALL relevant memories regardless of type unless explicitly requested.`,
   inputSchema: {
     type: "object",
     properties: {

package/dist/server.js

@@ -620,7 +620,9 @@ var ALL_MEMORY_PROPERTIES = [
   "tags",
   "weight",
   "base_weight",
-  "trust_level",
+  "trust",
+  // ✅ Fixed: was 'trust_level', schema has 'trust'
+  "confidence",
   "context",
   "location",
   "relationships",
@@ -1638,6 +1640,11 @@ var searchMemoryTool = {
   - "Show me notes from last week" \u2192 returns notes + any relationships created that week
   
   **AGENT GUIDANCE**:
+  - \u26A0\uFE0F **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add filters.types unless the user explicitly requests filtering by content type.
+    * \u2705 CORRECT: User says "search for hiking" \u2192 { query: "hiking" }
+    * \u274C WRONG: User says "search for hiking" \u2192 { query: "hiking", filters: { types: ["note"] } }
+    * \u2705 CORRECT: User says "search for note memories about hiking" \u2192 { query: "hiking", filters: { types: ["note"] } }
+    * Let the search algorithm find ALL relevant memories regardless of type unless explicitly requested.
   - If search results are too narrow or miss relevant content, try remember_query_memory instead - it uses pure semantic search which is better for broader, concept-based queries. You can inform the user: "I didn't find what you're looking for with keyword search. Let me try a broader semantic search using the query tool."
   - **CRITICAL**: If no results are returned, DO NOT make up or fabricate memories. Only report what was actually found. Tell the user honestly that no matching memories were found and suggest they:
     * Create a new memory with the information they're looking for
@@ -2208,6 +2215,11 @@ var queryMemoryTool = {
   - "What are my project goals?"
   
   **AGENT GUIDANCE**:
+  - \u26A0\uFE0F **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add filters.types unless the user explicitly requests filtering by content type.
+    * \u2705 CORRECT: User says "what do I know about hiking?" \u2192 { query: "hiking" }
+    * \u274C WRONG: User says "what do I know about hiking?" \u2192 { query: "hiking", filters: { types: ["note"] } }
+    * \u2705 CORRECT: User says "what notes do I have about hiking?" \u2192 { query: "hiking", filters: { types: ["note"] } }
+    * Let the query algorithm find ALL relevant memories regardless of type unless explicitly requested.
   - If query results are too broad or include irrelevant content, try remember_search_memory instead - it uses hybrid search with keyword matching which is better for precise, specific searches. You can inform the user: "The results were too broad. Let me try a more precise keyword search using the search tool."
   - **CRITICAL**: If no results are returned, DO NOT make up or fabricate memories. Only report what was actually found. Tell the user honestly that no matching memories were found and suggest they:
     * Create a new memory with the information they're looking for
@@ -4291,7 +4303,14 @@ import { Filters as Filters3 } from "weaviate-client";
 init_space_memory();
 var searchSpaceTool = {
   name: "remember_search_space",
-  description: "Search one or more shared spaces to discover thoughts, ideas, and memories. By default, excludes comments to keep discovery clean. Set include_comments: true to include threaded discussions. Can search multiple spaces in a single query.",
+  description: `Search one or more shared spaces to discover thoughts, ideas, and memories. By default, excludes comments to keep discovery clean. Set include_comments: true to include threaded discussions. Can search multiple spaces in a single query.
+
+\u26A0\uFE0F **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add content_type filter unless the user explicitly requests filtering by type.
+- \u2705 CORRECT: User says "search The Void for hiking" \u2192 { spaces: ["the_void"], query: "hiking" }
+- \u274C WRONG: User says "search The Void for hiking" \u2192 { spaces: ["the_void"], query: "hiking", content_type: "note" }
+- \u2705 CORRECT: User says "search The Void for note memories about hiking" \u2192 { spaces: ["the_void"], query: "hiking", content_type: "note" }
+
+Let the search algorithm find ALL relevant memories regardless of type unless explicitly requested.`,
   inputSchema: {
     type: "object",
     properties: {
@@ -4450,7 +4469,14 @@ import { Filters as Filters4 } from "weaviate-client";
 init_space_memory();
 var querySpaceTool = {
   name: "remember_query_space",
-  description: "Ask natural language questions about memories in shared spaces. By default, excludes comments to focus on original content. Set include_comments: true to include discussions in answers.",
+  description: `Ask natural language questions about memories in shared spaces. By default, excludes comments to focus on original content. Set include_comments: true to include discussions in answers.
+
+\u26A0\uFE0F **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add content_type filter unless the user explicitly requests filtering by type.
+- \u2705 CORRECT: User says "what's in The Void about hiking?" \u2192 { spaces: ["the_void"], question: "hiking" }
+- \u274C WRONG: User says "what's in The Void about hiking?" \u2192 { spaces: ["the_void"], question: "hiking", content_type: "note" }
+- \u2705 CORRECT: User says "what notes are in The Void about hiking?" \u2192 { spaces: ["the_void"], question: "hiking", content_type: "note" }
+
+Let the query algorithm find ALL relevant memories regardless of type unless explicitly requested.`,
   inputSchema: {
     type: "object",
     properties: {

package/dist/weaviate/client.d.ts

@@ -37,7 +37,7 @@ export declare function getAuditCollectionName(userId: string): string;
  * List of all memory properties to fetch
  * Centralized to ensure consistency across all tools
  */
-export declare const ALL_MEMORY_PROPERTIES: readonly ["user_id", "doc_type", "type", "title", "content", "tags", "weight", "base_weight", "trust_level", "context", "location", "relationships", "created_at", "updated_at", "version", "attribution", "source_url", "author", "parent_id", "thread_root_id", "moderation_flags"];
+export declare const ALL_MEMORY_PROPERTIES: readonly ["user_id", "doc_type", "type", "title", "content", "tags", "weight", "base_weight", "trust", "confidence", "context", "location", "relationships", "created_at", "updated_at", "version", "attribution", "source_url", "author", "parent_id", "thread_root_id", "moderation_flags"];
 /**
  * Fetch a memory object by ID with all properties
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/remember-mcp",
-  "version": "2.6.3",
+  "version": "2.6.5",
   "description": "Multi-tenant memory system MCP server with vector search and relationships",
   "main": "dist/server.js",
   "type": "module",

package/src/tools/query-memory.ts

@@ -35,6 +35,11 @@ export const queryMemoryTool = {
   - "What are my project goals?"
   
   **AGENT GUIDANCE**:
+  - ⚠️ **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add filters.types unless the user explicitly requests filtering by content type.
+    * ✅ CORRECT: User says "what do I know about hiking?" → { query: "hiking" }
+    * ❌ WRONG: User says "what do I know about hiking?" → { query: "hiking", filters: { types: ["note"] } }
+    * ✅ CORRECT: User says "what notes do I have about hiking?" → { query: "hiking", filters: { types: ["note"] } }
+    * Let the query algorithm find ALL relevant memories regardless of type unless explicitly requested.
   - If query results are too broad or include irrelevant content, try remember_search_memory instead - it uses hybrid search with keyword matching which is better for precise, specific searches. You can inform the user: "The results were too broad. Let me try a more precise keyword search using the search tool."
   - **CRITICAL**: If no results are returned, DO NOT make up or fabricate memories. Only report what was actually found. Tell the user honestly that no matching memories were found and suggest they:
     * Create a new memory with the information they're looking for

package/src/tools/query-space.ts

@@ -17,7 +17,14 @@ import { handleToolError } from '../utils/error-handler.js';
  */
 export const querySpaceTool: Tool = {
   name: 'remember_query_space',
-  description: 'Ask natural language questions about memories in shared spaces. By default, excludes comments to focus on original content. Set include_comments: true to include discussions in answers.',
+  description: `Ask natural language questions about memories in shared spaces. By default, excludes comments to focus on original content. Set include_comments: true to include discussions in answers.
+
+⚠️ **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add content_type filter unless the user explicitly requests filtering by type.
+- ✅ CORRECT: User says "what's in The Void about hiking?" → { spaces: ["the_void"], question: "hiking" }
+- ❌ WRONG: User says "what's in The Void about hiking?" → { spaces: ["the_void"], question: "hiking", content_type: "note" }
+- ✅ CORRECT: User says "what notes are in The Void about hiking?" → { spaces: ["the_void"], question: "hiking", content_type: "note" }
+
+Let the query algorithm find ALL relevant memories regardless of type unless explicitly requested.`,
   inputSchema: {
     type: 'object',
     properties: {

package/src/tools/search-memory.ts

@@ -34,6 +34,11 @@ export const searchMemoryTool = {
   - "Show me notes from last week" → returns notes + any relationships created that week
   
   **AGENT GUIDANCE**:
+  - ⚠️ **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add filters.types unless the user explicitly requests filtering by content type.
+    * ✅ CORRECT: User says "search for hiking" → { query: "hiking" }
+    * ❌ WRONG: User says "search for hiking" → { query: "hiking", filters: { types: ["note"] } }
+    * ✅ CORRECT: User says "search for note memories about hiking" → { query: "hiking", filters: { types: ["note"] } }
+    * Let the search algorithm find ALL relevant memories regardless of type unless explicitly requested.
   - If search results are too narrow or miss relevant content, try remember_query_memory instead - it uses pure semantic search which is better for broader, concept-based queries. You can inform the user: "I didn't find what you're looking for with keyword search. Let me try a broader semantic search using the query tool."
   - **CRITICAL**: If no results are returned, DO NOT make up or fabricate memories. Only report what was actually found. Tell the user honestly that no matching memories were found and suggest they:
     * Create a new memory with the information they're looking for

package/src/tools/search-space.ts

@@ -18,7 +18,14 @@ import type { SearchFilters } from '../types/memory.js';
  */
 export const searchSpaceTool: Tool = {
   name: 'remember_search_space',
-  description: 'Search one or more shared spaces to discover thoughts, ideas, and memories. By default, excludes comments to keep discovery clean. Set include_comments: true to include threaded discussions. Can search multiple spaces in a single query.',
+  description: `Search one or more shared spaces to discover thoughts, ideas, and memories. By default, excludes comments to keep discovery clean. Set include_comments: true to include threaded discussions. Can search multiple spaces in a single query.
+
+⚠️ **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add content_type filter unless the user explicitly requests filtering by type.
+- ✅ CORRECT: User says "search The Void for hiking" → { spaces: ["the_void"], query: "hiking" }
+- ❌ WRONG: User says "search The Void for hiking" → { spaces: ["the_void"], query: "hiking", content_type: "note" }
+- ✅ CORRECT: User says "search The Void for note memories about hiking" → { spaces: ["the_void"], query: "hiking", content_type: "note" }
+
+Let the search algorithm find ALL relevant memories regardless of type unless explicitly requested.`,
   inputSchema: {
     type: 'object',
     properties: {

package/src/weaviate/client.ts

@@ -152,7 +152,8 @@ export const ALL_MEMORY_PROPERTIES = [
   'tags',
   'weight',
   'base_weight',
-  'trust_level',
+  'trust',  // ✅ Fixed: was 'trust_level', schema has 'trust'
+  'confidence',
   'context',
   'location',
   'relationships',