> ## 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.

# Async Client

> Use the AsyncMemoryClient for non-blocking memory operations in high-concurrency Python applications.

The `AsyncMemoryClient` is an asynchronous client for interacting with the Mem0 API. It provides similar functionality to the synchronous `MemoryClient` but allows for non-blocking operations, which can be beneficial in applications that require high concurrency.

## Initialization

To use the async client, you first need to initialize it:

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import AsyncMemoryClient

  os.environ["MEM0_API_KEY"] = "your-api-key"

  client = AsyncMemoryClient()
  ```

  ```javascript JavaScript theme={null}
  const { MemoryClient } = require('mem0ai');
  const client = new MemoryClient({ apiKey: 'your-api-key'});
  ```
</CodeGroup>

## Methods

The `AsyncMemoryClient` provides the following methods:

### Add

Add a new memory asynchronously.

<CodeGroup>
  ```python Python theme={null}
  messages = [
      {"role": "user", "content": "Alice loves playing badminton"},
      {"role": "assistant", "content": "That's great! Alice is a fitness freak"},
  ]
  await client.add(messages, user_id="alice")
  ```

  ```javascript JavaScript theme={null}
  const messages = [
      {"role": "user", "content": "Alice loves playing badminton"},
      {"role": "assistant", "content": "That's great! Alice is a fitness freak"},
  ];
  await client.add(messages, { userId: "alice" });
  ```
</CodeGroup>

### Search

Search for memories based on a query asynchronously.

<CodeGroup>
  ```python Python theme={null}
  await client.search("What is Alice's favorite sport?", filters={"user_id": "alice"})
  ```

  ```javascript JavaScript theme={null}
  await client.search("What is Alice's favorite sport?", { filters: { userId: "alice" } });
  ```
</CodeGroup>

### Get All

Retrieve all memories for a user asynchronously.

<Callout type="warning" title="Filters Required">
  `get_all()` now requires filters to be specified.
</Callout>

<CodeGroup>
  ```python Python theme={null}
  await client.get_all(filters={"AND": [{"user_id": "alice"}]})
  ```

  ```javascript JavaScript theme={null}
  await client.getAll({ filters: {"AND": [{"user_id": "alice"}]} });
  ```
</CodeGroup>

### Delete

Delete a specific memory asynchronously.

<CodeGroup>
  ```python Python theme={null}
  await client.delete(memory_id="memory-id-here")
  ```

  ```javascript JavaScript theme={null}
  await client.delete("memory-id-here");
  ```
</CodeGroup>

### Delete All

Delete all memories for a user asynchronously.

<CodeGroup>
  ```python Python theme={null}
  await client.delete_all(user_id="alice")
  ```

  ```javascript JavaScript theme={null}
  await client.deleteAll({ userId: "alice" });
  ```
</CodeGroup>

<Note>
  At least one filter (`user_id`, `agent_id`, `app_id`, or `run_id`) is required: calling `delete_all` with no filters raises an error to prevent accidental data loss. You can pass `"*"` as a value to delete all memories for a given entity type (e.g., `user_id="*"` removes memories for every user). A full project wipe requires all four filters set to `"*"`.
</Note>

### History

Get the history of a specific memory asynchronously.

<CodeGroup>
  ```python Python theme={null}
  await client.history(memory_id="memory-id-here")
  ```

  ```javascript JavaScript theme={null}
  await client.history("memory-id-here");
  ```
</CodeGroup>

### Users

Get all users, agents, and runs which have memories associated with them asynchronously.

<CodeGroup>
  ```python Python theme={null}
  await client.users()
  ```

  ```javascript JavaScript theme={null}
  await client.users();
  ```
</CodeGroup>

### Reset

Reset the client, deleting all users and memories asynchronously.

<CodeGroup>
  ```python Python theme={null}
  await client.reset()
  ```

  ```javascript JavaScript theme={null}
  await client.reset();
  ```
</CodeGroup>

## Conclusion

The `AsyncMemoryClient` provides a powerful way to interact with the Mem0 API asynchronously, allowing for more efficient and responsive applications. By using this client, you can perform memory operations without blocking your application's execution.

If you have any questions or need further assistance, please don't hesitate to reach out:

<Snippet file="get-help.mdx" />