# Zep

> Give your workflows a memory. Zep remembers the people you deal with: what they said in past conversations and what your own systems know about them. Ask it a question, or pull back everything that matters right now as one block of text to hand straight to an AI step.

App · AI Search & Memory · 15 actions. Web page: https://docs.lodol.com/docs/integrations/zep

## Actions

### Add a person

Give Zep somebody to remember things about. Everything else in this integration hangs off a person, so this is the first step for anyone Zep has not met.

**Inputs**

- Person ID (`person_id`, text, required): How you will refer to this person from now on. Use whatever your own system already calls them, such as their email address or a customer number, so you never have to look it up.
- First name (`first_name`, text): Their first name.
- Last name (`last_name`, text): Their last name.
- Email address (`email`, text): Their email address.
- Time zone (`time_zone`, text): Where they are. Zep uses this to work out what dates like 'last Tuesday' mean when it reads something about them. One of: `Pacific/Honolulu` (Honolulu), `America/Anchorage` (Anchorage), `America/Los_Angeles` (Los Angeles (US Pacific)), `America/Denver` (Denver (US Mountain)), `America/Phoenix` (Phoenix (no daylight saving)), `America/Chicago` (Chicago (US Central)), `America/Mexico_City` (Mexico City), `America/New_York` (New York (US Eastern)), `America/Toronto` (Toronto), `America/Bogota` (Bogota), and 50 more.

**Outputs**

- `person` (object): Everything Zep holds against this person.
- `person_id` (text): The id this person is known by.

**Example output**

```json
{
  "person": {
    "created_at": "2026-09-18T09:14:22Z",
    "email": "ada@example.com",
    "first_name": "Ada",
    "last_name": "Lovelace",
    "user_id": "ada@example.com"
  },
  "person_id": "ada@example.com"
}
```

### Add messages to a conversation

Record what was said. Zep files the messages straight away and works out what they mean a few seconds later, so memory read immediately afterwards may not have caught up yet.

**Inputs**

- Conversation (`conversation_id`, text, required): Which conversation. Pick one Zep already has, or type the id of one an earlier step started.
- Messages (`messages`, list, required): What was said, in the order it was said. Each entry looks like {"role": "user", "content": "I moved to Austin last month."}. Roles are user, assistant, system, tool or function, and anything without one counts as the person speaking.
- Also bring back memory (`return_context`, true/false): Return the memory for this conversation as it stands after the last message, so a reply can be written without a second step. Default: `false`.

**Outputs**

- `context` (text): The memory for this conversation, when 'Also bring back memory' is ticked. Empty otherwise.
- `conversation_id` (text): The conversation they were added to.
- `message_count` (number): How many messages were added.
- `message_ids` (list): Zep's own id for each message.

**Example output**

```json
{
  "context": "",
  "conversation_id": "ticket-48213",
  "message_count": 2,
  "message_ids": [
    "9f2a1d3e-6c1b-4a2f-9e11-0d4f8b7c2a55",
    "1b7c4e90-2f3a-4c6d-8e12-5a9b3d7f1c02"
  ]
}
```

### Delete a conversation

Remove a conversation and its messages. What Zep learned from them stays in the person's memory; 'Delete a person' removes that too.

**Inputs**

- Conversation (`conversation_id`, text, required): Which conversation. Pick one Zep already has, or type the id of one an earlier step started.

**Outputs**

- `conversation_id` (text): The conversation that was deleted.
- `deleted` (true/false): Always true when the step succeeds.
- `message` (text): Zep's confirmation.

**Example output**

```json
{
  "conversation_id": "ticket-48213",
  "deleted": true,
  "message": "Thread deleted"
}
```

### Delete a person

Remove a person and everything Zep remembers about them, including their conversations. This cannot be undone.

**Inputs**

- Person (`person_id`, text, required): Who this is about. Pick someone Zep already knows, or type the id your own system uses for them, such as their email address.

**Outputs**

- `deleted` (true/false): Always true when the step succeeds.
- `message` (text): Zep's confirmation.
- `person_id` (text): The person who was deleted.

**Example output**

```json
{
  "deleted": true,
  "message": "User deleted",
  "person_id": "ada@example.com"
}
```

### Get a person

Read back the name, email address and time zone held against one person. For what Zep has learned about them, use 'Get a person's summary' instead.

**Inputs**

- Person (`person_id`, text, required): Who this is about. Pick someone Zep already knows, or type the id your own system uses for them, such as their email address.

**Outputs**

- `person` (object): Everything Zep holds against this person.
- `person_id` (text): The id this person is known by.

**Example output**

```json
{
  "person": {
    "created_at": "2026-09-18T09:14:22Z",
    "email": "ada@example.com",
    "first_name": "Ada",
    "last_name": "Lovelace",
    "time_zone": "Europe/London",
    "user_id": "ada@example.com"
  },
  "person_id": "ada@example.com"
}
```

### Get a person's summary

Zep's own written description of somebody, drawn from every conversation and record it has for them. Hand it to an AI step that needs to know who it is dealing with. Zep rewrites it as memory changes, so it can lag a few seconds behind something just added.

**Inputs**

- Person (`person_id`, text, required): Who this is about. Pick someone Zep already knows, or type the id your own system uses for them, such as their email address.

**Outputs**

- `attributes` (object): Details Zep has pulled out about them.
- `name` (text): What Zep calls this person in memory.
- `person_id` (text): The person this describes.
- `summary` (text): The description, or empty when Zep has not learned enough about them to write one yet.

**Example output**

```json
{
  "attributes": {
    "plan": "Scale"
  },
  "name": "Ada Lovelace",
  "person_id": "ada@example.com",
  "summary": "Ada is an enterprise customer on the Scale plan who switched from monthly to annual billing in June and cares most about audit logging."
}
```

### Get memory for a conversation

Everything Zep thinks matters right now in this conversation, written up as one block of text to hand to an AI step. It covers the whole person, not just this conversation.

**Inputs**

- Conversation (`conversation_id`, text, required): Which conversation. Pick one Zep already has, or type the id of one an earlier step started.

**Outputs**

- `context` (text): The memory, ready to hand to a model.
- `conversation_id` (text): The conversation this is for.
- `has_memory` (true/false): False when Zep has nothing to say yet, which is normal for a conversation that has just started.

**Example output**

```json
{
  "context": "FACTS:\n- Ada is on the Scale plan.\n- Ada asked about audit logging on 12 September 2026.",
  "conversation_id": "ticket-48213",
  "has_memory": true
}
```

### List a person's conversations

Every conversation Zep holds for one person.

**Inputs**

- Person (`person_id`, text, required): Who this is about. Pick someone Zep already knows, or type the id your own system uses for them, such as their email address.

**Outputs**

- `conversation_count` (number): How many there are.
- `conversations` (list): The conversations held with them.
- `person_id` (text): Whose conversations these are.

**Example output**

```json
{
  "conversation_count": 1,
  "conversations": [
    {
      "created_at": "2026-09-18T09:20:03Z",
      "thread_id": "ticket-48213",
      "user_id": "ada@example.com"
    }
  ],
  "person_id": "ada@example.com"
}
```

### List messages in a conversation

Read a conversation back, message by message. For what Zep has made of it, use 'Get memory for a conversation'.

**Inputs**

- Conversation (`conversation_id`, text, required): Which conversation. Pick one Zep already has, or type the id of one an earlier step started.
- Number of messages (`message_count`, number): How many of the most recent messages to bring back. From 1 to 500. Default: `50`.

**Outputs**

- `conversation_id` (text): The conversation these came from.
- `message_count` (number): How many messages came back.
- `messages` (list): The messages, oldest first.
- `person_id` (text): Who the conversation is with.
- `total_count` (number): How many the conversation holds in total.

**Example output**

```json
{
  "conversation_id": "ticket-48213",
  "message_count": 1,
  "messages": [
    {
      "content": "I moved to Austin last month.",
      "created_at": "2026-09-18T09:21:40Z",
      "role": "user",
      "uuid": "9f2a1d3e-6c1b-4a2f-9e11-0d4f8b7c2a55"
    }
  ],
  "person_id": "ada@example.com",
  "total_count": 1
}
```

### List people

Everyone this Zep project holds memory for, with an optional search across their ids, names and email addresses.

**Inputs**

- Search (`search`, text): Only return people whose id, name or email address matches. Leave empty for everyone.
- Order (`order`, text): How to sort the people that come back. One of: `newest` (Newest first), `oldest` (Oldest first), `id` (By ID, A to Z), `email` (By email address, A to Z). Default: `newest`.
- Number of people (`page_size`, number): How many people to return per page. From 1 to 200. Default: `50`.
- Page (`page`, number): Which page to return. Raise it by one to walk through a project with more people than fit on a page. From 1 to 10000. Default: `1`.

**Outputs**

- `people` (list): The people on this page.
- `person_count` (number): How many people are on this page.
- `total_count` (number): How many people the project has in total.

**Example output**

```json
{
  "people": [
    {
      "email": "ada@example.com",
      "first_name": "Ada",
      "last_name": "Lovelace",
      "user_id": "ada@example.com"
    }
  ],
  "person_count": 1,
  "total_count": 1
}
```

### List what Zep knows about a person

The whole dossier: one entry per thing Zep believes about somebody, with when it became true and, where it no longer is, when it stopped being true. Use 'Search a person's memory' when you have a question rather than a report.

**Inputs**

- Person (`person_id`, text, required): Who this is about. Pick someone Zep already knows, or type the id your own system uses for them, such as their email address.
- Number of facts (`fact_count`, number): How many facts to bring back. From 1 to 500. Default: `50`.
- Order (`order`, text): Sort by when Zep learned the fact, or by when the fact itself became true. One of: `newest` (Newest first), `oldest` (Oldest first), `became_true_newest` (By when it became true, most recent first), `became_true_oldest` (By when it became true, earliest first). Default: `newest`.

**Outputs**

- `fact_count` (number): How many facts came back.
- `facts` (list): Everything Zep believes about them.
- `person_id` (text): Who these facts are about.

**Example output**

```json
{
  "fact_count": 1,
  "facts": [
    {
      "created_at": "2026-09-18T09:21:55Z",
      "fact": "Ada Lovelace lives in Austin.",
      "name": "LIVES_IN",
      "uuid": "c41d6b8a-93f2-4e17-9a05-2b8e1f7c4d63",
      "valid_at": "2026-08-01T00:00:00Z"
    }
  ],
  "person_id": "ada@example.com"
}
```

### Remember something about a person

Add something that was not said in a conversation: an order, a support ticket, a CRM record, a page of notes. Zep reads it, works out what it means and files it with everything else it knows about them.

**Inputs**

- Person (`person_id`, text, required): Who this is about. Pick someone Zep already knows, or type the id your own system uses for them, such as their email address.
- What to remember (`data`, text, required): The text or the record itself, up to 10,000 characters. Hand it a record from an earlier step and Zep reads the fields; hand it writing and Zep reads the writing.
- What kind of thing this is (`data_type`, text): How Zep should read it. A record handed over by an earlier step is always read as a record, whatever is chosen here. One of: `text` (Written text, such as notes or a document), `json` (A record with fields, such as an order or a CRM row), `message` (Something somebody said). Default: `text`.
- Where it came from (`source_description`, text): A few words naming the source, such as 'Zendesk ticket' or 'Stripe invoice'. Zep keeps it with the record so you can tell later where a fact came from.
- When it happened (`happened_at`, date and time): When this actually took place. Leave it empty for now, and set it when loading something from the past so Zep puts it in the right order.

**Outputs**

- `person_id` (text): Whose memory this was added to.
- `record` (object): The stored record as Zep filed it.
- `record_id` (text): Zep's id for the record that was stored.

**Example output**

```json
{
  "person_id": "ada@example.com",
  "record": {
    "content": "{\"plan\": \"Scale\", \"renewed_on\": \"2026-06-01\"}",
    "created_at": "2026-09-18T09:25:11Z",
    "source": "json",
    "source_description": "Billing export",
    "uuid": "5e8b2c71-0a34-4f6d-bb19-73c2d5e4a908"
  },
  "record_id": "5e8b2c71-0a34-4f6d-bb19-73c2d5e4a908"
}
```

### Search a person's memory

Ask a question and get back what Zep knows that bears on it, across every conversation and record it holds for that person.

**Inputs**

- Person (`person_id`, text, required): Who this is about. Pick someone Zep already knows, or type the id your own system uses for them, such as their email address.
- What to look for (`query`, text, required): Describe it in plain language, such as 'what has this customer complained about before'.
- What to bring back (`scope`, text): The first choice collects across everything and writes it up as one block of text for an AI step, and hands back the results behind it as well. The rest return one kind of result and nothing else. One of: `auto` (Everything, written up ready to hand to an AI step), `edges` (Facts), `nodes` (People, places and things), `episodes` (The original messages and records), `thread_summaries` (Conversation recaps). Default: `auto`.
- Length of the written up memory (`summary_characters`, number): How long that block of text may be, in characters. Only used by the first choice above. From 100 to 50000. Default: `2500`.
- Number of results (`limit`, number): How many results the list choices return. Not used by the written up memory. From 1 to 50. Default: `10`.

**Outputs**

- `context` (text): The written up memory, ready to hand to a model. Empty unless the first choice was used.
- `conversation_recaps` (list): Matching conversation recaps.
- `entities` (list): Matching people, places and things.
- `facts` (list): Matching facts.
- `observations` (list): Patterns Zep has noticed over time, on the plans that include them.
- `person_id` (text): Whose memory was searched.
- `records` (list): Matching original messages and records.
- `result_count` (number): How many results came back in total.

**Example output**

```json
{
  "context": "FACTS:\n- Ada raised a billing complaint on 3 August 2026.\n- Ada's invoice was corrected the same week.",
  "conversation_recaps": [],
  "entities": [],
  "facts": [],
  "observations": [],
  "person_id": "ada@example.com",
  "records": [],
  "result_count": 0
}
```

### Start a conversation

Open a conversation to add messages to. Everything said in it goes into the person's memory, so what is learned in one conversation is known in the next.

**Inputs**

- Conversation ID (`conversation_id`, text, required): How you will refer to this conversation later. Use whatever the conversation already has a number for, such as a support ticket or a chat session.
- Person (`person_id`, text, required): Who this is about. Pick someone Zep already knows, or type the id your own system uses for them, such as their email address.

**Outputs**

- `conversation` (object): Everything Zep holds about the conversation.
- `conversation_id` (text): The id this conversation is known by.
- `person_id` (text): Who the conversation is with.

**Example output**

```json
{
  "conversation": {
    "created_at": "2026-09-18T09:20:03Z",
    "thread_id": "ticket-48213",
    "user_id": "ada@example.com"
  },
  "conversation_id": "ticket-48213",
  "person_id": "ada@example.com"
}
```

### Update a person

Change the name, email address or time zone held against one person. Anything left empty is left as it was.

**Inputs**

- Person (`person_id`, text, required): Who this is about. Pick someone Zep already knows, or type the id your own system uses for them, such as their email address.
- First name (`first_name`, text): Their first name.
- Last name (`last_name`, text): Their last name.
- Email address (`email`, text): Their email address.
- Time zone (`time_zone`, text): Where they are. Zep uses this to work out what dates like 'last Tuesday' mean when it reads something about them. One of: `Pacific/Honolulu` (Honolulu), `America/Anchorage` (Anchorage), `America/Los_Angeles` (Los Angeles (US Pacific)), `America/Denver` (Denver (US Mountain)), `America/Phoenix` (Phoenix (no daylight saving)), `America/Chicago` (Chicago (US Central)), `America/Mexico_City` (Mexico City), `America/New_York` (New York (US Eastern)), `America/Toronto` (Toronto), `America/Bogota` (Bogota), and 50 more.

**Outputs**

- `person` (object): Everything Zep holds against this person.
- `person_id` (text): The id this person is known by.

**Example output**

```json
{
  "person": {
    "email": "ada@analytical.example",
    "first_name": "Ada",
    "last_name": "Lovelace",
    "time_zone": "Europe/London",
    "user_id": "ada@example.com"
  },
  "person_id": "ada@example.com"
}
```