import { MemoryClient } from '@memra-client/client'

const memory = new MemoryClient({ apiKey: 'mk_live_...' })

export async function chat(userId: string, userMessage: string) {
  // 1. Pull relevant memories before the model responds
  const { context } = await memory.getContext(userId, userMessage)

  // Memory goes in system prompt — NOT in the user message
  // This tells the AI what the context is and how to use it
  const systemPrompt = context.length > 0
    ? `You are a helpful assistant with memory of past conversations.
Here is what you remember:
${context.map((m, i) => `${i + 1}. [${m.role}]: ${m.content}`).join('\n')}
Use this memory to give personalized responses.`
    : `You are a helpful assistant.`

  // 2. Pass context as system prompt — works with any AI provider
  const aiReply = await yourAI.chat.completions.create({
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user',   content: userMessage  },
    ],
  })

  // 3. Save this exchange to memory
  await memory.save(userId, userMessage, aiReply)

  return aiReply
}

import { MemoryClient } from '@memra-client/client'

const memory = new MemoryClient({
  apiKey: 'mk_live_...',           // required — from your dashboard
  baseUrl: 'https://memra.dev/api' // optional, this is the default
})

memory.save(
  userId: string,       // your end-user's identifier
  userMessage: string,  // the user's message text
  aiReply: string,      // the assistant's response text
  options?: {
    agentId?: string    // isolate memory per bot or context (default: 'default')
  }
): Promise<{ success: boolean; saved: number }>

{ success: boolean; saved: number }

const result = await memory.save(
  'user_abc123',
  'What is my current plan?',
  'You are on the Free plan — 500 memory slots available.',
  { agentId: 'support-bot' }
)
// => { success: true, saved: 2 }

memory.getContext(
  userId: string,
  query: string,         // the current message — used to find relevant memories
  options?: {
    agentId?: string     // filter to a specific agent namespace (default: 'default')
    limit?: number       // max memories returned (default: 5)
  }
): Promise<ContextResponse>

interface ContextResponse {
  context: Memory[]   // semantically relevant memories, ranked by similarity
  count: number
  latencyMs: number   // end-to-end search latency, added client-side
}

interface Memory {
  id: string
  content: string
  role: 'user' | 'assistant'
  createdAt: string
  similarity: number  // 0–1 cosine similarity score
}

const { context, latencyMs } = await memory.getContext(
  'user_abc123',
  'What plan am I on?',
  { agentId: 'support-bot', limit: 5 }
)

// context is sorted by similarity — highest first
context.forEach(m => {
  console.log(m.role + ':', m.content, '|', m.similarity.toFixed(2))
})

memory.getHistory(
  userId: string,
  options?: {
    agentId?: string   // filter by agent (omit = return all agents)
    limit?: number     // number of messages to return (default: 20)
  }
): Promise<{
  history: Memory[]   // chronological order, oldest first
  count: number
}>

const { history, count } = await memory.getHistory('user_abc123', {
  agentId: 'support-bot',
  limit: 50
})

console.log('Total messages:', count)
history.forEach(m => {
  console.log('[' + m.role + '] ' + m.content)
})

memory.forget(
  userId: string,
  options?: {
    agentId?: string   // omit to delete ALL memories for this user
  }
): Promise<{ success: boolean; deleted: number }>

// Clear only this agent's memory
await memory.forget('user_abc123', { agentId: 'support-bot' })

// Clear ALL memories for a user across every agent
const result = await memory.forget('user_abc123')
// => { success: true, deleted: 124 }

{ "success": true, "saved": 2 }

{
  "context": [
    {
      "id": "clx123abc",
      "content": "What is my plan?",
      "role": "user",
      "createdAt": "2026-06-15T10:00:00.000Z",
      "similarity": 0.94
    }
  ],
  "count": 1
}

curl 'https://memra.dev/api/memory/history?agentId=support-bot&limit=20' \
  -H 'x-api-key: mk_live_...'

{ "success": true, "deleted": 14 }

{
  "error": "Memory limit reached",
  "limit": 500,
  "plan": "free",
  "upgrade": "https://memra.dev/pricing"
}