Troubleshooting

console.log('API Key:', process.env.SATORI_API_KEY?.substring(0, 15) + '...');

# Make sure .env.local exists
cat .env.local

# Restart your development server after adding env vars
npm run dev

// Should start with 'sk_satori_'
if (!process.env.SATORI_API_KEY?.startsWith('sk_satori_')) {
  console.error('Invalid API key format');
}

const tools = memoryTools(config);

const result = await streamText({
  model: openai('gpt-4o'),
  messages,
  tools, // ← Make sure this is included
});

system: `You are a helpful assistant with memory.

When the user shares important information, use the add_item tool to save it.
Important information includes:
- Personal preferences
- Personal details
- Goals and intentions`

const result = await streamText({
  model: openai('gpt-4o'),
  messages,
  tools,
  maxSteps: 5, // ← Allow tool calls
});

User: "Remember that I love TypeScript"

const context = await getContext(config, userMessage);
console.log('Memory context:', context);

// Should output something like:
// "- User prefers TypeScript
//  - User loves hiking"

system: `You are a helpful assistant.

What you know about this user:
${memoryContext}  // ← Make sure this is included

Use this information to personalize responses.`

const client = new MemoryClient(config);
const all = await client.getAllMemories();
console.log('Total memories:', all.length);

// Lower threshold for broader matches
const context = await getContext(config, userMessage, {
  threshold: 0.6, // Default is 0.7
});

async function retryWithBackoff(fn: () => Promise<any>, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.message.includes('rate limit') && i < maxRetries - 1) {
        const delay = Math.pow(2, i) * 1000;
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
}

// Usage
await retryWithBackoff(() => client.addMemory('content'));

// Instead of multiple individual calls
const memories = ['memory1', 'memory2', 'memory3'];
await Promise.all(memories.map(m => client.addMemory(m)));

const contextCache = new Map<string, string>();

async function getCachedContext(query: string) {
  if (contextCache.has(query)) {
    return contextCache.get(query)!;
  }
  
  const context = await getContext(config, query);
  contextCache.set(query, context);
  return context;
}

// Fetch fewer memories
const context = await getContext(config, userMessage, {
  limit: 3, // Instead of 10
});

// Fetch context and start LLM call in parallel
const [memoryContext] = await Promise.all([
  getContext(config, userMessage),
  // Other async operations
]);

const embeddingCache = new Map();

async function getCachedContext(query: string) {
  const cacheKey = query.toLowerCase().trim();
  
  if (embeddingCache.has(cacheKey)) {
    return embeddingCache.get(cacheKey);
  }
  
  const context = await getContext(config, query);
  embeddingCache.set(cacheKey, context);
  
  // Clear cache after 5 minutes
  setTimeout(() => embeddingCache.delete(cacheKey), 5 * 60 * 1000);
  
  return context;
}

// Stream responses for better perceived performance
const result = await streamText({
  model: openai('gpt-4o'),
  messages,
  tools,
});

return result.toDataStreamResponse();

npm install --save-dev @types/node

import type { Memory, MemoryWithSimilarity } from '@usesatori/tools';

{
  "compilerOptions": {
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "moduleResolution": "bundler"
  }
}

cd packages/js-tools
npm run build

// ❌ Don't do this in client components
'use client';
const client = new MemoryClient({ apiKey: '...' }); // API key exposed!

// ✅ Do this instead - use API routes
export async function POST(req: Request) {
  // Server-side only
  const client = new MemoryClient({
    apiKey: process.env.SATORI_API_KEY!,
  });
}

// app/api/memories/route.ts
export async function GET() {
  const client = new MemoryClient({
    apiKey: process.env.SATORI_API_KEY!,
    baseUrl: process.env.SATORI_URL!,
    userId: 'user-123',
  });
  
  const memories = await client.getAllMemories();
  return Response.json({ memories });
}

// Make sure you have the correct UUID
console.log('Deleting memory:', memoryId);
await client.deleteMemory(memoryId);

// Memory IDs are scoped per user
const memories = await client.getAllMemories();
const exists = memories.some(m => m.id === memoryId);

if (!exists) {
  console.error('Memory not found for this user');
}

try {
  await client.deleteMemory(memoryId);
} catch (error) {
  if (error.message.includes('Not Found')) {
    console.log('Memory already deleted or does not exist');
  } else {
    throw error;
  }
}

// Search for similar memories first
const existing = await client.searchMemories(content, {
  threshold: 0.9, // High threshold for near-duplicates
  limit: 1,
});

if (existing.length === 0) {
  await client.addMemory(content);
} else {
  console.log('Similar memory already exists');
}

system: `Before saving a memory, consider if similar information already exists.
Only save truly new or updated information.`

// Find and merge duplicate memories
const memories = await client.getAllMemories();

for (let i = 0; i < memories.length; i++) {
  for (let j = i + 1; j < memories.length; j++) {
    const similarity = await calculateSimilarity(
      memories[i].content,
      memories[j].content
    );
    
    if (similarity > 0.95) {
      // Keep the newer one, delete the older
      await client.deleteMemory(memories[i].id);
      break;
    }
  }
}