indra_db_mcp 0.1.6 → 0.1.8

package/INDRA_INSTRUCTIONS.md

@@ -1,42 +1,33 @@
-# Indra: Versioned Thinking Tools
+# Indra: Your Knowledge Memory
 
-You have access to **Indra**, a knowledge graph for externalizing and versioning your reasoning. Use it proactively during complex tasks.
+You have access to **Indra**, a persistent memory for your insights and analysis.
 
 ## When to Use Indra
 
-**Search first** when starting work on a topic - you may have prior insights:
-- `indra_search` - Find related thoughts before duplicating work
+### BEFORE answering questions → `indra_search`
+- "What should I..." → Search for prior recommendations
+- "Which X is better..." → Search for past analysis
+- "How do I..." → Search for previous explanations
+- Any question about preferences, decisions, or past work
 
-**Remember** key insights as you work:
-- Observations, hypotheses, conclusions
-- Important patterns or surprises
-- Decisions and their rationale
-
-**Connect** related thoughts to build understanding:
-- Link new insights to prior ones (derives_from, supports, contradicts)
-- Build chains of reasoning visible in the graph
-
-**Branch** when exploring alternatives:
-- Create branches for "what if" scenarios
-- Compare different approaches
+### AFTER providing analysis → `indra_remember`
+- You made a recommendation → Save WHY you recommended it
+- You explained something → Save the key insight
+- You analyzed options → Save your conclusions
+- You learned user preferences → Save that context
 
 ## Quick Reference
 
-| Situation | Tool |
-|-----------|------|
-| Starting a task | `indra_search` for prior context |
-| Key insight | `indra_remember` to capture it |
-| Building on prior thought | `indra_connect` with relationship |
-| Exploring alternative | `indra_branch` then explore |
-| Finished analysis | `indra_checkpoint` with summary |
+| When | Tool | Example |
+|------|------|---------|
+| Before answering | `indra_search` | Search "gym shoes recommendation" |
+| After analyzing | `indra_remember` | Save "Recommended Hokas for cycling because..." |
+| Finishing a task | `indra_checkpoint` | "Completed workout gear analysis" |
 
-## Example Flow
+## Why This Matters
 
-```
-1. indra_search "database optimization" → find prior work
-2. indra_remember "Identified N+1 query in user loader" --id n-plus-one-finding
-3. indra_connect n-plus-one-finding --to prior-perf-analysis --relationship derives_from
-4. indra_checkpoint "Completed initial performance analysis"
-```
+Without Indra, every conversation starts from zero.
+With Indra, you build cumulative knowledge that improves over time.
 
-Use Indra to make your reasoning visible and traceable.
+Use `indra_search` BEFORE answering preference/recommendation questions.
+Use `indra_remember` AFTER providing analysis worth preserving.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indra_db_mcp",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "MCP server for indra_db - a content-addressed graph database for versioned thoughts",
   "type": "module",
   "bin": {

package/src/index.ts

@@ -32,37 +32,31 @@ import { EdgeTypes, IndraError } from "./types.js";
  * 2. When Claude should search for these tools
  * 3. Key capabilities the server provides
  */
-const SERVER_INSTRUCTIONS = `# Indra: Versioned Thinking Tools
-
-## What These Tools Do
-Indra provides a **knowledge graph for externalizing and versioning your reasoning**. 
-Think of it as git for your thoughts - capture insights, connect ideas, and track how 
-your understanding evolves over time.
-
-## When To Search For These Tools
-Use Indra tools when you are:
-- **Starting complex analysis** - Search for prior insights on the topic before beginning
-- **Having key insights** - Capture important observations, hypotheses, or conclusions
-- **Building on prior work** - Connect new thoughts to previous ones
-- **Exploring alternatives** - Branch to try different approaches without losing progress
-- **Completing a unit of work** - Checkpoint your progress with a meaningful summary
-
-## Key Capabilities
-- \`indra_search\` - Find prior thoughts by semantic meaning (not just keywords)
-- \`indra_remember\` - Capture a thought with optional memorable ID
-- \`indra_connect\` - Link thoughts with typed relationships (supports, contradicts, derives_from, etc.)
-- \`indra_branch\` / \`indra_switch_branch\` - Explore alternative lines of reasoning
-- \`indra_checkpoint\` - Save progress with a descriptive commit message
-- \`indra_list_thoughts\` / \`indra_explore\` - Review current state and connections
-
-## Usage Pattern
-1. Start sessions with \`indra_search\` to find relevant prior work
-2. Use \`indra_remember\` to capture key insights as you work
-3. Use \`indra_connect\` to link related thoughts
-4. Use \`indra_checkpoint\` when completing logical units of analysis
-
-The user has configured Indra because they want their reasoning process externalized 
-and versioned. Use these tools proactively during complex tasks.`;
+const SERVER_INSTRUCTIONS = `# Indra: Your Knowledge Memory
+
+## What This Is
+Indra is your persistent memory for insights, recommendations, and analysis.
+The user has configured this because they WANT you to build cumulative knowledge.
+
+## CRITICAL: When To Use These Tools
+
+### BEFORE answering questions → \`indra_search\`
+Search for prior knowledge when the user asks about:
+- Preferences, recommendations, or choices
+- Topics you may have discussed before
+- Anything that sounds familiar
+
+### AFTER learning something useful → \`indra_remember\`
+**Don't ask permission. Just save it.** The user configured Indra because they want this.
+Save when you:
+- Learn user preferences or context
+- Make recommendations with reasoning
+- Discover patterns or insights
+
+## The Pattern
+1. Search first (check what you know)
+2. Answer the question
+3. Save what you learned (don't ask, just do it)`;
 
 const server = new McpServer(
   {
@@ -118,27 +112,24 @@ function formatError(error: unknown): { content: Array<{ type: "text"; text: str
 
 server.tool(
   "remember",
-  `🧠 CAPTURE A THOUGHT - Crystallize an idea, insight, or realization into the knowledge graph.
+  `📝 SAVE INSIGHTS FOR LATER - Record useful information you've learned or analyzed.
 
-Use this when you:
-- Have an insight worth preserving
-- Want to externalize part of your reasoning
-- Need to create a reference point for later
-- Are building understanding incrementally
-
-The thought will be embedded for semantic search, allowing you to find it later 
-by meaning rather than exact words. Each thought becomes a node that can be 
-connected to others, forming a web of understanding.
-
-This is how you think out loud - make your reasoning visible and traceable.
-
-PROACTIVE TRIGGERS - Use this tool when you notice yourself:
-- Making a key observation or having an "aha" moment
-- Identifying an important pattern or insight
-- Drawing a conclusion from analysis
-- Forming a hypothesis or assumption
-- Noting something surprising or unexpected
-- Making a decision with rationale worth preserving`,
+The user has configured this tool because they WANT you to save insights.
+Don't ask permission - if you learned something useful, save it.
+
+SAVE when you:
+- Learn about user preferences (shoe choices, workout patterns, etc.)
+- Make a recommendation with reasoning worth preserving
+- Discover something about the user's situation or context
+- Analyze something that might be relevant again
+
+WHAT TO SAVE:
+- Key facts: "User is switching from Altra to Hoka for arch support"
+- Recommendations: "Recommended Hokas for cycling due to PF recovery"
+- Patterns: "User prefers cushioned shoes for recovery periods"
+- Context: "User has plantar fasciitis, resting foot this week"
+
+This creates searchable memory. Future sessions can find this context.`,
   {
     content: z.string().describe("The thought to capture - be specific and self-contained"),
     id: z.string().optional().describe("Optional memorable identifier (e.g., 'key-insight-about-X'). Auto-generated if not provided."),
@@ -365,29 +356,24 @@ find related concepts, or understand context.`,
 
 server.tool(
   "search",
-  `🔮 SEMANTIC SEARCH - Find thoughts by meaning, not just keywords.
+  `🔍 CHECK PRIOR KNOWLEDGE - Search for relevant context before answering questions.
 
-This is powerful: describe what you're looking for conceptually, and find 
-thoughts that match semantically. The embeddings capture meaning, so:
+CALL THIS FIRST when:
+- Answering questions about user preferences ("what do I like?", "which should I use?")
+- Making recommendations that might have prior context
+- Addressing topics you may have analyzed before
+- The user asks something that sounds familiar
 
-- "initial hypothesis" might find "my first theory about X"
-- "things that went wrong" might find "problems encountered"  
-- "key decisions" might find "we chose to..."
-
-Use this to:
-- Rediscover relevant prior thinking
-- Find thoughts to connect
-- Check if you've already captured something similar
-- Surface related ideas you may have forgotten
+This searches your saved analyses, recommendations, and insights by meaning.
+If you've reasoned about this topic before, you'll find it here.
 
-Higher scores = more semantically similar.
+EXAMPLES:
+- User asks "what shoes for the gym?" → search "gym shoes recommendation"
+- User asks "how should I structure this?" → search "architecture decisions"
+- User asks "what's my preference?" → search the relevant topic
 
-PROACTIVE TRIGGERS - Use this tool when you:
-- Start working on a new task (search for related prior work)
-- Need context on a topic you've explored before
-- Want to avoid duplicating previous insights
-- Are about to make a decision (check if you've reasoned about this)
-- Feel like "I think I've thought about this before"`,
+Returns prior insights ranked by relevance. Use them to give consistent, 
+informed answers that build on past reasoning.`,
   {
     query: z.string().describe("What you're looking for - describe the meaning/concept"),
     limit: z.number().min(1).max(100).default(10).describe("Maximum results to return"),