> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mem0.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Build a Node.js Companion

> Build a JavaScript fitness coach that remembers user goals run after run.

You can create a personalized AI Companion using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.

## Overview

The Personalized AI Companion leverages Mem0 to retain information across interactions, enabling a tailored learning experience. It creates memories for each user interaction and integrates with OpenAI's GPT models to provide detailed and context-aware responses to user queries.

## Setup

Before you begin, ensure you have Node.js installed and create a new project. Install the required dependencies using npm:

```bash theme={null}
npm install openai mem0ai
```

## Full Code Example

Below is the complete code to create and interact with an AI Companion using Mem0:

```javascript theme={null}
import { OpenAI } from 'openai';
import { Memory } from 'mem0ai/oss';
import * as readline from 'readline';

const openaiClient = new OpenAI();
const memory = new Memory();

async function chatWithMemories(message, userId = "default_user") {
  const relevantMemories = await memory.search(message, { filters: { user_id: userId } });
  
  const memoriesStr = relevantMemories.results
    .map(entry => `- ${entry.memory}`)
    .join('\n');
  
  const systemPrompt = `You are a helpful AI. Answer the question based on query and memories.
User Memories:
${memoriesStr}`;
  
  const messages = [
    { role: "system", content: systemPrompt },
    { role: "user", content: message }
  ];
  
  const response = await openaiClient.chat.completions.create({
    model: "gpt-5-mini",
    messages: messages
  });
  
  const assistantResponse = response.choices[0].message.content || "";
  
  messages.push({ role: "assistant", content: assistantResponse });
  await memory.add(messages, { userId: userId });
  
  return assistantResponse;
}

async function main() {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });
  
  console.log("Chat with AI (type 'exit' to quit)");
  
  const askQuestion = () => {
    return new Promise((resolve) => {
      rl.question("You: ", (input) => {
        resolve(input.trim());
      });
    });
  };
  
  try {
    while (true) {
      const userInput = await askQuestion();
      
      if (userInput.toLowerCase() === 'exit') {
        console.log("Goodbye!");
        rl.close();
        break;
      }
      
      const response = await chatWithMemories(userInput, "sample_user");
      console.log(`AI: ${response}`);
    }
  } catch (error) {
    console.error("An error occurred:", error);
    rl.close();
  }
}

main().catch(console.error);
```

### Key Components

1. **Initialization**
   * The code initializes both OpenAI and Mem0 Memory clients
   * Uses Node.js's built-in readline module for command-line interaction

2. **Memory Management (chatWithMemories function)**
   * Retrieves relevant memories using Mem0's search functionality
   * Constructs a system prompt that includes past memories
   * Makes API calls to OpenAI for generating responses
   * Stores new interactions in memory

3. **Interactive Chat Interface (main function)**
   * Creates a command-line interface for user interaction
   * Handles user input and displays AI responses
   * Includes graceful exit functionality

### Environment Setup

Make sure to set up your environment variables:

```bash theme={null}
export OPENAI_API_KEY=your_api_key
```

### Conclusion

This implementation demonstrates how to create an AI Companion that maintains context across conversations using Mem0's memory capabilities. The system automatically stores and retrieves relevant information, creating a more personalized and context-aware interaction experience.

As users interact with the system, Mem0's memory system continuously learns and adapts, making future responses more relevant and personalized. This setup is ideal for creating long-term learning AI assistants that can maintain context and provide increasingly personalized responses over time.

***

<CardGroup cols={2}>
  <Card title="Partition Memories by Entity" icon="layers" href="/cookbooks/essentials/entity-partitioning-playbook">
    Separate user, agent, and session context to keep your companion consistent.
  </Card>

  <Card title="Quickstart Demo with Mem0" icon="rocket" href="/cookbooks/companions/quickstart-demo">
    Run the full showcase app to see memory-powered companions in action.
  </Card>
</CardGroup>