Node.js SDK

npm install @jeanmemory/node

import { JeanClient } from '@jeanmemory/node';
import { OpenAIStream, StreamingTextResponse } from 'ai';
import OpenAI from 'openai';

// Create the clients
const jean = new JeanClient({ apiKey: process.env.JEAN_API_KEY });
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Set the runtime to edge for best performance
export const runtime = 'edge';

export default async function POST(req: Request) {
  // 1. Get the user's message and token from the request body
  const { messages, userToken } = await req.json();
  const currentMessage = messages[messages.length - 1].content;

  // Ensure the user token is present
  if (!userToken) {
    return new Response('Unauthorized', { status: 401 });
  }

  // 2. Get context from Jean Memory with speed control
  const contextResponse = await jean.getContext({
    user_token: userToken,
    message: currentMessage,
    speed: "balanced", // Options: "fast", "balanced", "autonomous", "comprehensive"
    // tool="jean_memory", format="enhanced" (defaults)
  });

  // 3. Engineer your final prompt
  const finalPrompt = `
    Using the following context, please answer the user's question.
    The context is a summary of the user's memories related to their question.

    Context:
    ---
    ${contextResponse.text}
    ---

    User Question: ${currentMessage}
  `;
  
  // 4. Call your LLM and stream the response
  const response = await openai.chat.completions.create({
    model: 'gpt-4-turbo',
    stream: true,
    messages: [
      { role: "system", content: "You are a helpful assistant." },
      { role: "user", content: finalPrompt },
    ],
  });

  const stream = OpenAIStream(response);
  return new StreamingTextResponse(stream);
}

// With user token (production)
const context = await jean.getContext({
  user_token: userToken,  // From OAuth flow
  message: "What's my schedule?"
});

// Backward compatibility string overload (automatic test user)
const context = await jean.getContext("What's my schedule?");

// Fast: Direct memory search (0.5-1s)
const fastContext = await jean.getContext({
  user_token: userToken,
  message: "What's my schedule?",
  speed: "fast"
});

// Balanced: AI synthesis with Gemini 2.5 Flash (3-5s) - Recommended
const balancedContext = await jean.getContext({
  user_token: userToken,
  message: "How should I handle this situation?",
  speed: "balanced"
});

// Autonomous: Intelligent orchestration (variable latency)
const smartContext = await jean.getContext({
  user_token: userToken,
  message: "Help me plan my project timeline",
  speed: "autonomous"
});

// Comprehensive: Deep document analysis (20-30s)
const deepContext = await jean.getContext({
  user_token: userToken,
  message: "Analyze patterns in my communication style",
  speed: "comprehensive"
});

// Different tools for specific needs
const context = await jean.getContext({
  user_token: userToken,
  message: currentMessage,
  tool: "search_memory"  // vs "jean_memory" (default)
});

// Simple text response instead of full metadata
const context = await jean.getContext({
  user_token: userToken,
  message: currentMessage,
  format: "simple"  // vs "enhanced" (default)
});

// The intelligent, orchestrated way (recommended):
const context = await jean.getContext({ user_token: ..., message: "..." });

// The deterministic, tool-based way:
await jean.tools.add_memory({ user_token: ..., content: "My project's deadline is next Friday." });

const search_results = await jean.tools.search_memory({ user_token: ..., query: "project deadlines" });
// Parse search results - they come as JSON in content[0].text
const searchData = JSON.parse(search_results.content[0].text);
console.log('Found memories:', searchData.memories);

// Advanced tools for complex operations:
try {
  const deep_results = await jean.tools.deep_memory_query({ user_token: ..., query: "complex relationship query" });
  // Deep queries return analysis directly in content[0].text
  const analysis = deep_results.content[0].text;
  console.log('Deep analysis:', analysis);
} catch (error) {
  console.error('Deep query failed:', error);
  // Fallback to regular search
}

const doc_result = await jean.tools.store_document({ 
  user_token: ..., 
  title: "Meeting Notes", 
  content: "...", 
  document_type: "markdown" 
});

{
  content: [
    {
      type: "text", 
      text: "JSON string or direct text response"
    }
  ]
}