{
  "info": {
    "name": "Mem0 — mcp.ai",
    "description": "REST API for the Mem0 MCP. Set {{apiKey}} to a workspace key (sk_live_…) created at https://mcp.ai/settings/api-keys.",
    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
  },
  "auth": {
    "type": "bearer",
    "bearer": [
      {
        "key": "token",
        "value": "{{apiKey}}",
        "type": "string"
      }
    ]
  },
  "variable": [
    {
      "key": "baseUrl",
      "value": "https://api.mcp.ai/api/mem0",
      "type": "string"
    },
    {
      "key": "apiKey",
      "value": "sk_live_...",
      "type": "string"
    }
  ],
  "item": [
    {
      "name": "mem0_add_member_to_project",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/add/member/to/project",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "add",
            "member",
            "to",
            "project"
          ]
        },
        "description": "Adds an existing user to a project (identified by `project_id` within organization `org_id`), assigning a valid system role.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"role\": \"\",\n  \"email\": \"\",\n  \"org_id\": \"\",\n  \"project_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_add_new_memory_records",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/add/new/memory/records",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "add",
            "new",
            "memory",
            "records"
          ]
        },
        "description": "Stores new memory records from a list of messages, optionally inferring structured content; requires association via `agent_id`, `user_id`, `app_id`, or `run_id`.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"infer\": false,\n  \"app_id\": \"\",\n  \"org_id\": \"\",\n  \"run_id\": \"\",\n  \"user_id\": \"\",\n  \"agent_id\": \"\",\n  \"excludes\": \"\",\n  \"includes\": \"\",\n  \"messages\": \"\",\n  \"org_name\": \"\",\n  \"async_mode\": false,\n  \"project_id\": \"\",\n  \"project_name\": \"\",\n  \"output_format\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_add_organization_member",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/add/organization/member",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "add",
            "organization",
            "member"
          ]
        },
        "description": "Adds a new member, who must be a registered user, to an organization, assigning them a specific role.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"role\": \"\",\n  \"email\": \"\",\n  \"org_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_create_a_new_agent",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/create/a/new/agent",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "create",
            "a",
            "new",
            "agent"
          ]
        },
        "description": "Creates a new agent with a unique `agent_id` and an optional `name`; additional metadata may be assigned by the system.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"name\": \"\",\n  \"agent_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_create_a_new_agent_run",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/create/a/new/agent/run",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "create",
            "a",
            "new",
            "agent",
            "run"
          ]
        },
        "description": "Creates a new agent run in the mem0.ai system.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"name\": \"\",\n  \"run_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_create_a_new_application",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/create/a/new/application",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "create",
            "a",
            "new",
            "application"
          ]
        },
        "description": "Creates a new application, allowing metadata to be passed in the request body (not an explicit field in this action's request model); ensure `app_id` is unique to avoid potential errors or unintended ",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"name\": \"\",\n  \"app_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_create_a_new_organization_entry",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/create/a/new/organization/entry",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "create",
            "a",
            "new",
            "organization",
            "entry"
          ]
        },
        "description": "Creates a new organization entry using the provided name and returns its details.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"name\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_create_a_new_user",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/create/a/new/user",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "create",
            "a",
            "new",
            "user"
          ]
        },
        "description": "Creates a new user with the specified unique `user_id` and supports associating `metadata` (not part of the request schema fields).",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"user_id\": \"\",\n  \"metadata\": {}\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_create_memory_entry",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/create/memory/entry",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "create",
            "memory",
            "entry"
          ]
        },
        "description": "Lists/searches existing memory entries with filtering and pagination; critically, this action retrieves memories and does *not* create new ones, despite its name.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"page\": 0,\n  \"org_id\": \"\",\n  \"filters\": {},\n  \"org_name\": \"\",\n  \"page_size\": 0,\n  \"project_id\": \"\",\n  \"project_name\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_create_project",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/create/project",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "create",
            "project"
          ]
        },
        "description": "Creates a new project with a given name within an organization that must already exist.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"name\": \"\",\n  \"org_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_create_webhook",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/create/webhook",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "create",
            "webhook"
          ]
        },
        "description": "Creates a new webhook for a specific project to receive real-time notifications. Use when you need to set up event-driven integrations that trigger on memory operations.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"url\": \"\",\n  \"name\": \"\",\n  \"is_active\": false,\n  \"project_id\": \"\",\n  \"event_types\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_delete_a_specific_memory_by_id",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/delete/a/specific/memory/by/id",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "delete",
            "a",
            "specific",
            "memory",
            "by",
            "id"
          ]
        },
        "description": "Permanently deletes a specific memory by its unique ID; ensure the `memory_id` exists as this operation is irreversible.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"memory_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_delete_an_organization",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/delete/an/organization",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "delete",
            "an",
            "organization"
          ]
        },
        "description": "Permanently deletes an existing organization identified by its unique ID.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"org_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_delete_entity_by_type_and_id",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/delete/entity/by/type/and/id",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "delete",
            "entity",
            "by",
            "type",
            "and",
            "id"
          ]
        },
        "description": "Call to permanently and irreversibly hard-delete an existing entity (user, agent, app, or run) and all its associated data, using its type and ID.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"entity_id\": \"\",\n  \"entity_type\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_delete_memories_endpoint",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/delete/memories/endpoint",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "delete",
            "memories",
            "endpoint"
          ]
        },
        "description": "Deletes all memories matching specified filter criteria. IMPORTANT: At least one filter (agent_id, user_id, app_id, or run_id) must be provided to prevent accidental deletion of all memories. Requires",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"app_id\": \"\",\n  \"org_id\": \"\",\n  \"run_id\": \"\",\n  \"user_id\": \"\",\n  \"agent_id\": \"\",\n  \"metadata\": {},\n  \"org_name\": \"\",\n  \"project_id\": \"\",\n  \"project_name\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_delete_memory_batch_with_uuids",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/delete/memory/batch/with/uuids",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "delete",
            "memory",
            "batch",
            "with",
            "uuids"
          ]
        },
        "description": "Deletes a batch of up to 1000 existing memories, identified by their UUIDs, in a single API call.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"memories\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_delete_project",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/delete/project",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "delete",
            "project"
          ]
        },
        "description": "Permanently deletes a specific project and all its associated data from an organization; this action cannot be undone and requires the project to exist within the specified organization.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"org_id\": \"\",\n  \"project_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_delete_project_member",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/delete/project/member",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "delete",
            "project",
            "member"
          ]
        },
        "description": "Removes an existing member, specified by email address, from a project, immediately revoking their project-specific access; the user is not removed from the organization.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"email\": \"\",\n  \"org_id\": \"\",\n  \"project_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_delete_webhook",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/delete/webhook",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "delete",
            "webhook"
          ]
        },
        "description": "Deletes a webhook and stops receiving notifications for the specified webhook ID. Use this when you no longer need webhook notifications or want to remove a specific webhook configuration.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"webhook_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_export_data_based_on_filters",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/export/data/based/on/filters",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "export",
            "data",
            "based",
            "on",
            "filters"
          ]
        },
        "description": "Creates a new memory export job with optional entity filters (user_id, agent_id, app_id, run_id). Returns export job ID and confirmation message. Requires org_id and project_id. Uses default schema fo",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"app_id\": \"\",\n  \"org_id\": \"\",\n  \"run_id\": \"\",\n  \"schema\": {},\n  \"filters\": {},\n  \"user_id\": \"\",\n  \"agent_id\": \"\",\n  \"project_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_fetch_detailed_list_of_organizations",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/fetch/detailed/list/of/organizations",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "fetch",
            "detailed",
            "list",
            "of",
            "organizations"
          ]
        },
        "description": "Retrieves a summary list of organizations for administrative oversight; returns summary data (names, IDs), not exhaustive details, despite 'detailed' in the name.",
        "body": {
          "mode": "raw",
          "raw": "{}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_fetch_details_of_a_specific_organization",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/fetch/details/of/a/specific/organization",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "fetch",
            "details",
            "of",
            "a",
            "specific",
            "organization"
          ]
        },
        "description": "Fetches comprehensive details for an organization using its `org_id`; the `org_id` must be valid and for an existing organization.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"org_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_fetch_list_of_entity_filters",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/fetch/list/of/entity/filters",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "fetch",
            "list",
            "of",
            "entity",
            "filters"
          ]
        },
        "description": "Retrieves predefined filter definitions for entities (e.g., by type, creation/modification date); returns definitions only, not filtered entity data.",
        "body": {
          "mode": "raw",
          "raw": "{}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_fetch_specific_entity_details_with_optional_filters",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/fetch/specific/entity/details/with/optional/filters",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "fetch",
            "specific",
            "entity",
            "details",
            "with",
            "optional",
            "filters"
          ]
        },
        "description": "Fetches detailed information for an existing entity (user, agent, app, or run) identified by its type and unique ID.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"entity_id\": 0,\n  \"entity_type\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_get_event_status_by_event_id",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/get/event/status/by/event/id",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "get",
            "event",
            "status",
            "by",
            "event",
            "id"
          ]
        },
        "description": "Retrieves a single async event by ID to check its current status and results. Use this after operations that return event IDs (e.g., add_new_memory_records) to poll for completion before proceeding wi",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"event_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_get_memories_by_entity",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/get/memories/by/entity",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "get",
            "memories",
            "by",
            "entity"
          ]
        },
        "description": "Tool to retrieve all memories associated with a specific entity (user, agent, app, or run). Use when you need to fetch memories for a known entity type and ID combination.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"page\": 0,\n  \"entity_id\": \"\",\n  \"page_size\": 0,\n  \"entity_type\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_get_memory_export",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/get/memory/export",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "get",
            "memory",
            "export"
          ]
        },
        "description": "Retrieves the status and results of a memory export job by its ID. Use this after creating an export job to fetch the processed memory data. The response structure matches the schema defined during ex",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"org_id\": \"\",\n  \"project_id\": \"\",\n  \"memory_export_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_get_organization_members",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/get/organization/members",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "get",
            "organization",
            "members"
          ]
        },
        "description": "Fetches a list of members for a specified, existing organization.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"org_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_get_project_details",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/get/project/details",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "get",
            "project",
            "details"
          ]
        },
        "description": "Fetches comprehensive details for a specified project within an organization.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"org_id\": \"\",\n  \"project_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_get_project_members",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/get/project/members",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "get",
            "project",
            "members"
          ]
        },
        "description": "Retrieves all members for a specified project within an organization.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"org_id\": \"\",\n  \"project_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_get_project_webhooks",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/get/project/webhooks",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "get",
            "project",
            "webhooks"
          ]
        },
        "description": "Retrieves all webhooks configured for a specific project. Use this to list webhook configurations including their event types, URLs, and active status.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"project_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_get_projects",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/get/projects",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "get",
            "projects"
          ]
        },
        "description": "Retrieves all projects for a given organization `org_id` to which the caller has access.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"org_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_get_user_memory_stats",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/get/user/memory/stats",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "get",
            "user",
            "memory",
            "stats"
          ]
        },
        "description": "Retrieves a summary of the authenticated user's memory activity, including total memories created, search events, and add events. Note: This endpoint is undocumented in the official mem0 API specifica",
        "body": {
          "mode": "raw",
          "raw": "{}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_list_entities_with_optional_org_and_project_filters",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/list/entities/with/optional/org/and/project/filters",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "list",
            "entities",
            "with",
            "optional",
            "org",
            "and",
            "project",
            "filters"
          ]
        },
        "description": "Retrieves a list of entities, optionally filtered by organization or project (prefer `org_id`/`project_id` over deprecated `org_name`/`project_name`), noting results may be summaries and subject to li",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"org_id\": \"\",\n  \"org_name\": \"\",\n  \"project_id\": \"\",\n  \"project_name\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_perform_semantic_search_on_memories",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/perform/semantic/search/on/memories",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "perform",
            "semantic",
            "search",
            "on",
            "memories"
          ]
        },
        "description": "Searches memories semantically using a natural language query and metadata filters. IMPORTANT: - At least one of 'user_id', 'agent_id', or 'run_id' MUST be provided - A non-empty 'query' string is REQ",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"query\": \"\",\n  \"top_k\": 0,\n  \"app_id\": \"\",\n  \"fields\": \"\",\n  \"org_id\": \"\",\n  \"rerank\": false,\n  \"run_id\": \"\",\n  \"user_id\": \"\",\n  \"agent_id\": \"\",\n  \"metadata\": {},\n  \"org_name\": \"\",\n  \"categories\": \"\",\n  \"project_id\": \"\",\n  \"project_name\": \"\",\n  \"output_format\": \"\",\n  \"filter_memories\": false,\n  \"only_metadata_based_search\": false\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_remove_a_member_from_the_organization",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/remove/a/member/from/the/organization",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "remove",
            "a",
            "member",
            "from",
            "the",
            "organization"
          ]
        },
        "description": "Removes a member, specified by their username, from an existing organization of which they are currently a member.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"email\": \"\",\n  \"org_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_retrieve_all_events_for_the_currently_logged_in_user",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/retrieve/all/events/for/the/currently/logged/in/user",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "retrieve",
            "all",
            "events",
            "for",
            "the",
            "currently",
            "logged",
            "in",
            "user"
          ]
        },
        "description": "Retrieves a paginated list of events for the authenticated user, filterable and paginable via URL query parameters. This is a read-only operation that does not modify data. Supported Query Parameters ",
        "body": {
          "mode": "raw",
          "raw": "{}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_retrieve_list_of_memory_events",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/retrieve/list/of/memory/events",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "retrieve",
            "list",
            "of",
            "memory",
            "events"
          ]
        },
        "description": "Retrieves a chronological list of all memory events (e.g., user inputs, AI responses) from the Mem0 platform, providing interaction history and context for AI assistants.",
        "body": {
          "mode": "raw",
          "raw": "{}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_retrieve_memory_by_unique_identifier",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/retrieve/memory/by/unique/identifier",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "retrieve",
            "memory",
            "by",
            "unique",
            "identifier"
          ]
        },
        "description": "Retrieves a complete memory entry by its unique identifier; `memory_id` must be valid and for an existing memory.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"memory_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_retrieve_memory_history_by_id",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/retrieve/memory/history/by/id",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "retrieve",
            "memory",
            "history",
            "by",
            "id"
          ]
        },
        "description": "Retrieves the complete version history for an existing memory, using its unique `memory_id`, to inspect its evolution or audit changes.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"memory_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_retrieve_memory_list",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/retrieve/memory/list",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "retrieve",
            "memory",
            "list"
          ]
        },
        "description": "Retrieves a list of memories, supporting pagination and diverse filtering (e.g., by IDs, metadata, keywords, date ranges); ensure dates are ISO 8601 and `page`/`page_size` (if used) are positive integ",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"page\": 0,\n  \"app_id\": \"\",\n  \"fields\": \"\",\n  \"org_id\": \"\",\n  \"run_id\": \"\",\n  \"user_id\": \"\",\n  \"agent_id\": \"\",\n  \"end_date\": \"\",\n  \"keywords\": \"\",\n  \"metadata\": {},\n  \"org_name\": \"\",\n  \"page_size\": 0,\n  \"categories\": \"\",\n  \"project_id\": \"\",\n  \"start_date\": \"\",\n  \"project_name\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_search_memories_with_query_filters",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/search/memories/with/query/filters",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "search",
            "memories",
            "with",
            "query",
            "filters"
          ]
        },
        "description": "Semantically searches memories using structured filters with an optional natural language query. If query is omitted, defaults to '*' (wildcard) for filter-only searches. Offers options to rerank resu",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"query\": \"\",\n  \"top_k\": 0,\n  \"fields\": \"\",\n  \"org_id\": \"\",\n  \"rerank\": false,\n  \"filters\": {},\n  \"org_name\": \"\",\n  \"threshold\": 0,\n  \"project_id\": \"\",\n  \"project_name\": \"\",\n  \"keyword_search\": false,\n  \"filter_memories\": false\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_update_memory_batch_with_uuid",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/update/memory/batch/with/uuid",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "update",
            "memory",
            "batch",
            "with",
            "uuid"
          ]
        },
        "description": "Updates text for up to 1000 memories in a single batch, using their UUIDs.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"org_id\": \"\",\n  \"memories\": \"\",\n  \"project_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_update_memory_details_by_id",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/update/memory/details/by/id",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "update",
            "memory",
            "details",
            "by",
            "id"
          ]
        },
        "description": "Updates the text content of an existing memory, identified by its `memory_id`.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"text\": \"\",\n  \"metadata\": {},\n  \"memory_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_update_organization_member_role",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/update/organization/member/role",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "update",
            "organization",
            "member",
            "role"
          ]
        },
        "description": "Updates the role of an existing member to a new valid role within an existing organization.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"role\": \"\",\n  \"email\": \"\",\n  \"org_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_update_project",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/update/project",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "update",
            "project"
          ]
        },
        "description": "Updates a project by `project_id` within an `org_id`, modifying only provided fields (name, description, custom_instructions, custom_categories); list fields are fully replaced (cleared by `[]`), othe",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"name\": \"\",\n  \"org_id\": \"\",\n  \"project_id\": \"\",\n  \"description\": \"\",\n  \"custom_categories\": \"\",\n  \"custom_instructions\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    },
    {
      "name": "mem0_update_project_member_role",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "{{baseUrl}}/update/project/member/role",
          "host": [
            "{{baseUrl}}"
          ],
          "path": [
            "update",
            "project",
            "member",
            "role"
          ]
        },
        "description": "Updates the role of a specific member within a designated project, ensuring the new role is valid and recognized by the system.",
        "body": {
          "mode": "raw",
          "raw": "{\n  \"role\": \"\",\n  \"email\": \"\",\n  \"org_id\": \"\",\n  \"project_id\": \"\"\n}",
          "options": {
            "raw": {
              "language": "json"
            }
          }
        }
      }
    }
  ]
}