import { OpenMemory } from '@openmemory/sdk-js'

// Initialize client
const memory = new OpenMemory({
  baseUrl: 'http://localhost:8080',
  apiKey: 'your-api-key' // optional
})

// Add memories (auto-classified into brain sectors)
const result = await memory.add("I felt really excited about the AI conference yesterday")
console.log(`Stored in ${result.sector} sector`) // -> "emotional" or "episodic"

// Query memories with semantic search
const memories = await memory.query("conference excitement", { k: 5 })
console.log(`Found ${memories.matches.length} relevant memories`)

// Query specific brain sectors
const emotions = await memory.querySector("happy feelings", "emotional")
const habits = await memory.querySector("morning routine", "procedural")

const client = new OpenMemory({
  baseUrl?: string,    // Default: 'http://localhost:8080'
  apiKey?: string,     // Optional API key
  timeout?: number     // Request timeout in ms, default: 60000
})

// Simple add
const result = await client.add("I learned about vector databases today")

// With metadata and options
const result = await client.add("Python is great for data science", {
  tags: ["programming", "data-science"],
  metadata: { source: "learning", difficulty: "beginner" },
  salience: 0.8,        // Importance (0-1)
  decay_lambda: 0.01    // Custom decay override
})

// Returns: { id: string, sector: SectorType }

// Basic query
const results = await client.query("machine learning concepts")

// Advanced query with filters
const results = await client.query("happy memories", {
  k: 10,                    // Max results
  filters: {
    sector: "emotional",    // Search specific sector
    min_score: 0.7,        // Minimum similarity score
    tags: ["personal"]      // Filter by tags
  }
})

// Returns: { query: string, matches: QueryMatch[] }

// Search emotional memories
const emotions = await client.querySector("stress and anxiety", "emotional")

// Search habits and routines
const routines = await client.querySector("morning habits", "procedural", 5)

// Standard reinforcement
await client.reinforce(memoryId)

// Strong reinforcement  
await client.reinforce(memoryId, 0.5)

// Get first 50 memories
const result = await client.getAll()

// Pagination and filtering
const result = await client.getAll({
  limit: 20,
  offset: 40,
  sector: "semantic"  // Optional sector filter
})

// Get all emotional memories
const emotions = await client.getBySector("emotional")

// With pagination
const facts = await client.getBySector("semantic", 50, 100)

await client.delete(memoryId)

const { sectors, stats } = await client.getStats()

stats.forEach(stat => {
  console.log(`${stat.sector}: ${stat.count} memories`)
  console.log(`Average salience: ${stat.avg_salience}`)
})

// Temporal/event patterns → episodic
await client.add("I met Sarah at the coffee shop last Tuesday")

// Emotional patterns → emotional
await client.add("I feel excited about the new project")

// Procedural patterns → procedural  
await client.add("My workflow: review PRs, then write code")

// Facts/knowledge → semantic (default)
await client.add("TypeScript is a superset of JavaScript")

// Meta/reflective → reflective
await client.add("I notice I'm most productive in the morning")

// Force specific sector via metadata
await client.add("Important deadline coming up", {
  metadata: { sector: "emotional" }  // Override classification
})

import { OpenMemory } from '@openmemory/sdk-js'

const memory = new OpenMemory({
  baseUrl: process.env.OPENMEMORY_URL,
  apiKey: process.env.OPENMEMORY_API_KEY
})

// Use in API routes, background jobs, etc.

import { OpenMemory } from '@openmemory/sdk-js'

function useMemory() {
  const [client] = useState(() => new OpenMemory({
    baseUrl: 'https://your-memory-api.com'
  }))
  
  const addMemory = async (content: string) => {
    return await client.add(content)
  }
  
  return { addMemory, query: client.query.bind(client) }
}

import { OpenMemory } from '@openmemory/sdk-js'

export default async function handler(req: Request) {
  const memory = new OpenMemory({
    baseUrl: 'https://memory-api.example.com'
  })
  
  const result = await memory.query(req.query.q)
  return Response.json(result)
}

import { 
  OpenMemory, 
  Memory, 
  QueryMatch, 
  SectorType, 
  SECTORS 
} from '@openmemory/sdk-js'

// Type-safe sector operations
const sector: SectorType = 'emotional'
const sectorInfo = SECTORS[sector]

// Typed responses
const memories: QueryMatch[] = (await client.query("test")).matches
const memory: Memory = memories[0]

// Batch multiple adds
const promises = contents.map(content => client.add(content))
const results = await Promise.all(promises)

// Reuse client instance
const client = new OpenMemory({ baseUrl: 'https://api.com' })

// Don't create new instance per request
// ❌ const client = new OpenMemory() // in every function call

// Use specific sectors for faster queries
const emotions = await client.querySector("happy", "emotional")

// Set appropriate minimum scores
const results = await client.query("search", {
  filters: { min_score: 0.8 }  // Higher threshold = fewer, better results
})

try {
  const result = await client.add("Memory content")
} catch (error) {
  if (error.message.includes('401')) {
    console.error('Authentication required')
  } else if (error.message.includes('429')) {
    console.error('Rate limited, retry later')
  } else {
    console.error('Unknown error:', error)
  }
}

// With timeout handling
const client = new OpenMemory({ 
  timeout: 30000  // 30 second timeout
})