## Overview

Organizations and projects provide multi-tenant support, access control, and team collaboration capabilities for Mem0 Platform. Use these APIs to build applications that support multiple teams, customers, or isolated environments.

Organizations and projects are **optional** features. You can use Mem0 without them for single-user or simple multi-user applications.

## Key Capabilities

- **Multi-org/project Support**: Organization and project are resolved automatically from your API key via `/v1/ping/`: no org or project params are accepted by `MemoryClient.__init__`. Use a project-specific API key to target a particular project.
- **Member Management**: Control access to data through organization and project membership.
- **Access Control**: Only members can access memories and data within their organization/project scope.
- **Team Isolation**: Maintain data separation between different teams and projects for secure collaboration.

## Using Organizations & Projects

### Initialize with Org/Project Context

Example with the mem0 Python package:

```python
from mem0 import MemoryClient
client = MemoryClient(api_key="your-api-key")
```

```javascript
import { MemoryClient } from "mem0ai";
const client = new MemoryClient({ apiKey: "your-api-key" });
```

## Project Management

The Mem0 client provides comprehensive project management through the `client.project` interface:

### Get Project Details

Retrieve information about the current project:

```python
# Get all project details
project_info = client.project.get()

# Get specific fields only
project_info = client.project.get(fields=["name", "description", "custom_categories"])
```

### Create a New Project

Create a new project within your organization:

```python
# Create a project with name and description
new_project = client.project.create(
    name="My New Project",
    description="A project for managing customer support memories"
)
```

### Update Project Settings

Modify project configuration including custom instructions, categories, language preferences, and memory decay:

```python
# Update project with custom categories
client.project.update(
    custom_categories=[
        {"customer_preferences": "Customer likes, dislikes, and preferences"},
        {"support_history": "Previous support interactions and resolutions"}
    ]
)

# Update project with custom instructions
client.project.update(
    custom_instructions="..."
)

# Use the input language for memory storage and retrieval
client.project.update(multilingual=True)

# Enable Memory Decay (boosts recently-accessed memories at search time)
client.project.update(decay=True)

# Update multiple settings at once
client.project.update(
    custom_instructions="...",
    custom_categories=[
        {"personal_info": "User personal information and preferences"},
        {"work_context": "Professional context and work-related information"}
    ],
    multilingual=True
)
```

#### Toggle Memory Decay

`decay` is a per-project boolean that turns on [Memory Decay](https://docs.mem0.ai/platform/features/memory-decay): a search-time ranking bias that reinforces recently-accessed memories and gently dampens stale ones. The flag is `false` by default; set it via the same project-update endpoint:

```bash
curl -X PATCH https://api.mem0.ai/api/v1/orgs/organizations/$ORG_ID/projects/$PROJECT_ID/ \
  -H "Authorization: Token $MEM0_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"decay": true}'
```

The current state is returned on every project read (and supports `?fields=decay` for a minimal response). Toggling has no effect on stored memories, only on how v3 search ranks them.

### Delete Project

This action will remove all memories, messages, and other related data in the project. **This operation is irreversible.**

Remove a project and all its associated data:

```python
# Delete the current project (irreversible)
result = client.project.delete()
```

## Member Management

Manage project members and their access levels:

```python
# Get all project members
members = client.project.get_members()

# Add a new member as a reader
client.project.add_member(
    email="colleague@company.com",
    role="READER"  # or "OWNER"
)

# Update a member's role
client.project.update_member(
    email="colleague@company.com",
    role="OWNER"
)

# Remove a member from the project
client.project.remove_member(email="colleague@company.com")
```

### Member Roles

| Role | Permissions |
| --- | --- |
| **READER** | Can view and search memories, but cannot modify project settings or manage members |
| **OWNER** | Full access including project modification, member management, and all reader permissions |

## Async Support

All project methods are available in async mode:

```python
from mem0 import AsyncMemoryClient

async def manage_project():
    client = AsyncMemoryClient(api_key="your-api-key")

# All methods support async/await
    project_info = await client.project.get()
    await client.project.update(multilingual=True)
    members = await client.project.get_members()

# To call the async function properly
import asyncio
asyncio.run(manage_project())
```

## API Reference

For complete API specifications and additional endpoints, see:

[**Organizations APIs**  
Create, get, and manage organizations](https://docs.mem0.ai/api-reference/organization/create-org)

[**Project APIs**  
Full project CRUD and member management endpoints](https://docs.mem0.ai/api-reference/project/create-project)