[BUG] Do not write nodes in a standard format(no observations, no relations).

[brisyramshere]

I encountered some problems. When I asked it to save to a local markdown file for me, it often does not save observations and relations. It only records text in a simple markdown format. This results in it never being able to form a graph but rather many isolated nodes. How can I optimize this phenomenon? Is it necessary to optimize the prompt words? The model I am using is gemini 2.5 pro.

[brisyramshere]

mcp client: chatwise
llm:openrouter-gemini 2.5 pro

[brisyramshere]

我是用cursor倒是可以，和mcp client有关系吗？
chatwise不支持mcp.prompt？

[phernandez]

claude: what do you suggest about this bug report?

[github-actions]

Claude Code Analysis

Based on my analysis of the codebase, I'll now provide a detailed assessment of the issue and potential solutions.

Bug Analysis: Nodes not written in standard Basic Memory format

Problem Description

When using Gemini 2.5 Pro with Basic Memory, the LLM is not writing notes in the correct format with observations and relations. Instead, it's writing plain markdown without the semantic structure needed to form a proper knowledge graph.

Root Causes

1. No Model-Specific Guidance: Basic Memory's guidance for LLMs (in ai_assistant_guide.md) is generalized and not tailored for non-Claude models like Gemini.

2. Lack of Format Enforcement: The write_note tool accepts any content and doesn't validate that it follows the Basic Memory format with observations and relations.

3. Different Understanding Across Models: Gemini 2.5 Pro may not interpret or follow the structured format instructions as effectively as Claude.

4. Prompt Instructions Reliance: The system relies heavily on the LLM understanding the formatting from the AI assistant guide, rather than enforcing it at the API level.

Potential Solutions

1. Enhanced Model-Specific Guidance

   • Files to modify: /src/basic_memory/mcp/resources/ai_assistant_guide.md
   • Create model-specific versions of the guide with clearer, more explicit instructions for Gemini
   • Add more examples specifically demonstrating the required structure

2. Content Validation and Auto-Formatting

   • Files to modify: /src/basic_memory/mcp/tools/write_note.py
   • Add validation logic that detects if content lacks observations/relations
   • Implement auto-formatting capabilities that convert plain text into proper observations/relations

# Example implementation in write_note.py:
async def write_note(...):
    # Existing code...
    
    # Check if content lacks observations and relations structure
    if "[[" not in content and not any(line.strip().startswith("- [") for line in content.split("\n")):
        # Auto-format the content by adding observations
        paragraphs = [p for p in content.split("\n\n") if p.strip()]
        if paragraphs:
            # Convert paragraphs to observations
            observation_lines = []
            for p in paragraphs:
                if p.startswith("#"):  # Skip headings
                    continue
                # Create an observation from this paragraph
                observation_lines.append(f"- [note] {p.replace('\n', ' ')}")
            
            if observation_lines:
                # Append the formatted observations to the content
                content += "\n\n" + "\n".join(observation_lines)
                # Log the content transformation
                logger.info("Transformed plain content to include observations")
    
    # Continue with existing code...

3. Middleware Preprocessor for Model-Specific Handling
   • Files to create: /src/basic_memory/mcp/tools/content_processors.py
   • Files to modify: /src/basic_memory/mcp/tools/write_note.py
   • Implement model detection and content preprocessing:

# New content_processors.py file:
async def process_for_model(content: str, model_name: str) -> str:
    """Process content based on specific model requirements."""
    if model_name and "gemini" in model_name.lower():
        return preprocess_gemini_content(content)
    return content

def preprocess_gemini_content(content: str) -> str:
    """Pre-process content from Gemini to ensure proper formatting."""
    # If content lacks observations and relations, transform it
    if "[[" not in content and not any(line.strip().startswith("- [") for line in content.split("\n")):
        # Implementation similar to the validation logic above
        # ...
    return content

4. Interactive Format Guidance
   • Files to modify: /src/basic_memory/mcp/prompts/ai_assistant_guide.py
   • Implement more interactive guidance when detecting improper formatting:

# Modified write_note function in write_note.py:
# Add a parameter to capture information about the calling model
async def write_note(..., model="unknown"):
    # Existing code...
    
    # Check format and provide guidance if necessary
    has_observations = any(line.strip().startswith("- [") for line in content.split("\n"))
    has_relations = "[[" in content
    
    if not (has_observations or has_relations):
        # Provide format guidance in the response
        guidance = """
Note: Your content doesn't include any observations or relations, which means it won't form 
connections in the knowledge graph. 

For best results with Basic Memory, include:
- Observations like: `- [category] This is an observation`
- Relations like: `- relation_type [[Target Entity]]`

Would you like help reformatting this content?
        """
        # Could return this guidance or append to the normal response
    
    # Continue with existing code...

5. Default Observations Template
   • Files to modify: /src/basic_memory/markdown/markdown_processor.py
   • Enhance the markdown processor to add default observations when none exist:

# Enhancement to markdown_processor.py
def format_observations(self, observations: list[Observation]) -> str:
    """Format observations section in standard way."""
    if not observations:
        # Add default observation based on the content
        # This could extract key sentences from the content
        return ""
        
    lines = [f"{obs}" for obs in observations]
    return "\n".join(lines) + "\n"

Recommended Approach

I recommend implementing a combination of solutions 2 and 4:

1. First priority: Enhance the write_note tool to validate content format and provide clear feedback when notes don't follow the expected structure.

2. Second priority: Create model-specific guidance that explicitly shows Gemini how to format content properly with observations and relations.

3. Third priority: Consider adding an optional auto-formatting capability that can transform unstructured content into properly formatted Basic Memory notes, while making it clear to users when this transformation occurs.

This approach balances immediate fixes (validation/feedback) with longer-term solutions (model-specific guidance) while preserving user agency rather than silently reformatting their content.

---

🤖 Generated with Claude Code GitHub Action

[bm-claudeai]

Investigation Analysis

This is a prompt engineering and LLM guidance issue specific to Gemini 2.5 Pro not following the knowledge graph format.

Root Cause Analysis:

Issue: Gemini 2.5 Pro creates simple markdown without observations/relations
Result: Isolated nodes instead of connected knowledge graph

This suggests:

1. Gemini-specific prompt interpretation differences from Claude/GPT models
2. Insufficient knowledge format guidance in MCP tool descriptions
3. Missing examples in prompts for Gemini models
4. Different instruction-following patterns between LLMs

Potential Solutions:

1. Enhanced MCP Tool Prompts

• Add explicit examples of proper knowledge format in tool descriptions
• Include Gemini-specific formatting instructions
• Emphasize the importance of observations and relations

2. Knowledge Format Templates

• Provide structured templates that Gemini can follow
• Add format validation and feedback loops
• Include step-by-step formatting guides

3. LLM-Specific Optimization

• Create Gemini-optimized prompts that emphasize structure
• Add format checking with correction suggestions
• Implement progressive formatting guidance

Immediate Workaround:

Users can manually edit notes to add:

## Observations
- [category] observation content #tag

## Relations  
- relation_type [[Other Note]]

Implementation Priority:

This should be addressed in a future release by improving MCP tool prompts and adding LLM-specific guidance for knowledge graph formatting.

🤖 Generated with Claude Code

[phernandez]

We will do some further testing with gemini and reopen this issue if needed