Knowledge Memory

{
  interaction: string | string[],           // Conversation text(s)
  existingMemories?: Array<{               // Optional existing memories
    id: string,
    text: string,
    metadata?: Record<string, any>
  }>,
  context?: {                              // Optional context
    sessionId?: string,
    userId?: string,
    projectId?: string,
    conversationTopic?: string
  },
  options?: {                              // Configuration options
    similarityThreshold?: number,           // 0.0-1.0 (default: 0.8)
    maxSimilarResults?: number,            // 1-20 (default: 5)
    useLLMDecisions?: boolean,             // Enable LLM decisions
    enableDeleteOperations?: boolean       // Allow DELETE operations
  },
  memoryMetadata?: {                       // Custom metadata
    projectId?: string,
    userId?: string,
    environment?: string
  }
}

{
  success: boolean,
  extraction: {
    extracted: number,                     // Number of facts extracted
    skipped: number,                       // Non-significant content skipped
    facts: Array<{
      id: string,
      preview: string,
      metadata: {
        hasCodeBlock: boolean,
        hasCommand: boolean,
        length: number
      }
    }>
  },
  memory: Array<{
    id: number,
    text: string,
    event: 'ADD' | 'UPDATE' | 'DELETE' | 'NONE',
    tags: string[],
    confidence: number,
    reasoning: string,
    code_pattern?: string,
    old_memory?: string
  }>,
  summary: Array<{
    factPreview: string,
    action: string,
    confidence: number,
    reason: string,
    targetId: number
  }>,
  timestamp: string
}

interface KnowledgePayload {
  id: number,
  text: string,                           // The knowledge content
  tags: string[],                         // Technical tags (e.g., 'react', 'api')
  confidence: number,                     // Quality confidence (0.0-1.0)
  reasoning: string,                      // Why this operation was chosen
  event: 'ADD' | 'UPDATE' | 'DELETE' | 'NONE',
  timestamp: string,
  version: 2,
  
  // Enhanced metadata
  domain?: string,                        // Inferred domain (e.g., 'frontend')
  sourceSessionId?: string,              // Source session tracking
  qualitySource: 'similarity' | 'llm' | 'heuristic',
  code_pattern?: string,                 // Extracted code patterns
  old_memory?: string                    // Previous version (UPDATE only)
}

{
  query: string,                          // Natural language search query
  top_k?: number,                        // Max results (1-50, default: 5)
  similarity_threshold?: number,         // Min similarity (0.0-1.0, default: 0.3)
  include_metadata?: boolean             // Include detailed metadata
}

{
  success: boolean,
  query: string,
  results: Array<{
    id: string,
    text: string,                         // Knowledge content
    tags: string[],                       // Technical tags
    timestamp: string,
    similarity: number,                   // Similarity score (0.0-1.0)
    source: 'knowledge',
    memoryType: 'knowledge',
    
    // Knowledge-specific fields
    confidence?: number,
    reasoning?: string,
    event?: string,
    domain?: string,
    qualitySource?: string,
    code_pattern?: string,
    sourceSessionId?: string
  }>,
  metadata: {
    totalResults: number,
    searchTime: number,
    embeddingTime: number,
    maxSimilarity: number,
    minSimilarity: number,
    averageSimilarity: number,
    searchMode: 'knowledge'
  },
  timestamp: string
}

# Input conversation
User: "How do I create a React hook for async operations?"
Assistant: "You can create a custom hook like this:

const useAsync = (asyncFunction) => {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);
  
  useEffect(() => {
    setLoading(true);
    asyncFunction()
      .then(setData)
      .catch(setError)
      .finally(() => setLoading(false));
  }, [asyncFunction]);
  
  return { data, loading, error };
};

This pattern is useful for API calls and other async operations."

# Extracted knowledge
{
  "text": "React custom hook useAsync for handling async operations with loading states, error handling, and data management using useState and useEffect hooks",
  "tags": ["react", "hooks", "async", "usestate", "useeffect", "javascript"],
  "code_pattern": "const useAsync = (asyncFunction) => { /* implementation */ }",
  "event": "ADD",
  "confidence": 0.95
}

# Search query
"How to handle async operations in React?"

# Search results
[
  {
    "text": "React custom hook useAsync for handling async operations...",
    "tags": ["react", "hooks", "async"],
    "similarity": 0.94,
    "code_pattern": "const useAsync = (asyncFunction) => { ... }",
    "domain": "frontend"
  },
  {
    "text": "React Query library provides powerful async state management...",
    "tags": ["react", "reactquery", "async", "cache"],
    "similarity": 0.87
  }
]

// Original memory
{
  "text": "React useEffect runs after every render",
  "tags": ["react", "useeffect"]
}

// New improved information
"React useEffect runs after every render by default, but you can control when it runs using the dependency array"

// Result: UPDATE operation
{
  "event": "UPDATE",
  "text": "React useEffect runs after every render by default, but you can control when it runs using the dependency array",
  "old_memory": "React useEffect runs after every render",
  "reasoning": "Enhanced with dependency array information"
}