### Setup and Installation Commands

Source: https://github.com/getzep/zep/blob/main/examples/typescript/eve/README.md

Commands to navigate to the project directory, configure environment variables, and install dependencies.

```bash
cd examples/typescript/eve
```

```bash
cp .env.example .env
```

```bash
npm install
```

--------------------------------

### Run Example Agent

Source: https://github.com/getzep/zep/blob/main/integrations/adk/python/SETUP.md

Commands to execute the basic agent example from the repository or after pip installation.

```bash
uv run python examples/basic_agent.py
```

```bash
python examples/basic_agent.py
```

--------------------------------

### Setup Development Environment

Source: https://github.com/getzep/zep/blob/main/integrations/crewai/python/README.md

Commands to clone the repository and install necessary dependencies for development.

```bash
# Clone the repository
git clone https://github.com/getzep/zep.git
cd integrations/crewai/python

# Install dependencies
pip install -e .
pip install -r requirements-dev.txt
```

--------------------------------

### Setup React App

Source: https://github.com/getzep/zep/blob/main/examples/python/elevenlabs-zep-example/README.md

Commands to install dependencies and configure the React frontend.

```bash
cd react-app
```

```bash
npm install
```

```bash
cp .env.example .env
```

```text
VITE_ELEVENLABS_AGENT_ID=your_agent_id_here
```

```bash
npm run dev
```

--------------------------------

### Development Environment Setup

Source: https://github.com/getzep/zep/blob/main/ingestion/SETUP.md

Clone the repository and use make commands to install dependencies and run quality checks.

```bash
git clone https://github.com/getzep/zep
cd zep/ingestion
make install    # uv sync --extra dev
make all        # format + lint + type-check + test
```

--------------------------------

### Install and Run Zep Ingest Examples

Source: https://github.com/getzep/zep/blob/main/ingestion/examples/README.md

Commands to install the package, configure the API key, and execute a sample script.

```bash
pip install zep-ingest
export ZEP_API_KEY=...   # Zep dashboard → Project → API Keys
cd examples
python slack_export_example.py
```

--------------------------------

### Run the Example Agent

Source: https://github.com/getzep/zep/blob/main/integrations/adk/go/SETUP.md

Execute the bundled example agent.

```bash
go run ./examples
```

--------------------------------

### Environment Setup

Source: https://github.com/getzep/zep/blob/main/examples/python/claude-prompt-caching-example/README.md

Commands to initialize the virtual environment, install dependencies, and configure environment variables.

```bash
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env   # then fill in both keys
```

--------------------------------

### Development Environment Setup

Source: https://github.com/getzep/zep/blob/main/integrations/autogen/python/README.md

Commands to install dependencies and execute pre-commit checks for the project.

```bash
# Install development dependencies
make install

# Run pre-commit checks (format, lint, type-check, test)
make pre-commit
```

--------------------------------

### Run examples

Source: https://github.com/getzep/zep/blob/main/integrations/vercel-ai/typescript/SETUP.md

Commands to execute the provided generate-text and stream-text examples.

```bash
npm install
npm run example                 # generate-text.ts (middleware + tools)
npx tsx examples/stream-text.ts # streamText + onFinish persistence
```

--------------------------------

### Setup Development Environment

Source: https://github.com/getzep/zep/blob/main/integrations/livekit/python/README.md

Commands to clone the repository and install necessary dependencies for the LiveKit Python integration.

```bash
git clone https://github.com/getzep/zep
cd zep/integrations/livekit/python
make install
```

--------------------------------

### Install from repository

Source: https://github.com/getzep/zep/blob/main/integrations/crewai/python/SETUP.md

Clone the repository and install dependencies using uv.

```bash
git clone https://github.com/getzep/zep.git
cd zep/integrations/crewai/python
make install        # uv sync --extra dev
```

--------------------------------

### Run Store Agent Example

Source: https://github.com/getzep/zep/blob/main/integrations/langgraph/python/SETUP.md

Execute the ZepStore agent example.

```bash
uv run python examples/store_agent.py   # only needs ZEP_API_KEY
```

--------------------------------

### Run Ingestion Examples

Source: https://github.com/getzep/zep/blob/main/ingestion/SETUP.md

Execute the provided example scripts from the examples directory.

```bash
cd examples
python slack_export_example.py
python email_example.py
```

--------------------------------

### Install Dependencies

Source: https://github.com/getzep/zep/blob/main/integrations/strands/python/SETUP.md

Install the necessary packages using pip or set up the development environment using uv.

```bash
pip install zep-strands 'strands-agents[openai]'
```

```bash
git clone https://github.com/getzep/zep.git
cd zep/integrations/strands/python
make install        # uv sync --extra dev (includes strands-agents[openai])
```

--------------------------------

### Setup Zep Python ADK Environment

Source: https://github.com/getzep/zep/blob/main/integrations/adk/python/README.md

Commands to clone the repository and install necessary dependencies for development.

```bash
git clone https://github.com/getzep/zep.git
cd integrations/adk/python
make install
```

--------------------------------

### Install Zep MS Agent Framework dependencies

Source: https://github.com/getzep/zep/blob/main/integrations/ms-agent-framework/python/README.md

Install the core integration package and the optional OpenAI provider for runnable examples.

```bash
pip install zep-ms-agent-framework
```

```bash
pip install zep-ms-agent-framework agent-framework-openai
```

--------------------------------

### Run the example agent

Source: https://github.com/getzep/zep/blob/main/integrations/adk/typescript/SETUP.md

Execute the provided example agent using npm or npx.

```bash
npm run example
# or, directly:
npx tsx examples/basic-agent.ts
```

--------------------------------

### Initialize Environment Configuration

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/docs/DOCKER.md

Prepare the environment file by copying the example and setting the required API key.

```bash
cp .env.example .env
# Edit .env and add your ZEP_API_KEY
```

--------------------------------

### Verify installation

Source: https://github.com/getzep/zep/blob/main/integrations/adk/typescript/SETUP.md

Run these commands to verify the installation, run tests, and build the project.

```bash
npm run typecheck   # tsc --noEmit
npm test            # vitest (mocked Zep client — no API key needed)
npm run build       # tsup → dist
```

--------------------------------

### Run Example Script

Source: https://github.com/getzep/zep/blob/main/examples/python/openai-agents-sdk/README.md

Execute the example script with various flags for interactive mode, user info, and session management.

```bash
python openai_agents_sdk_example.py
```

```bash
python openai_agents_sdk_example.py --interactive
```

```bash
python openai_agents_sdk_example.py --username user123 --email user@example.com --firstname John --lastname Doe
```

```bash
python openai_agents_sdk_example.py --username user123 --session my-session-id
```

--------------------------------

### Run example scripts

Source: https://github.com/getzep/zep/blob/main/integrations/crewai/python/SETUP.md

Execute the example scripts using either uv or standard python.

```bash
uv run python examples/simple_example.py
```

```bash
python examples/simple_example.py
```

--------------------------------

### Install Dependencies

Source: https://github.com/getzep/zep/blob/main/examples/python/agent-memory-full-example/README.md

Commands to set up the virtual environment and install necessary Python packages.

```bash
# Create a virtual environment
python -m venv venv

# Activate the virtual environment
# On macOS/Linux:
source venv/bin/activate
# On Windows:
# venv\Scripts\activate

# Install required packages
pip install -r requirements.txt
```

--------------------------------

### Install Dependencies

Source: https://github.com/getzep/zep/blob/main/examples/python/openai-agents-sdk/README.md

Install project dependencies using uv or poetry.

```bash
uv sync
```

```bash
poetry install
```

--------------------------------

### Install Zep ADK

Source: https://github.com/getzep/zep/blob/main/integrations/adk/python/SETUP.md

Installation commands for the Zep ADK package using pip or local repository setup.

```bash
pip install zep-adk
```

```bash
git clone https://github.com/getzep/zep.git
cd zep/integrations/adk/python
make install        # uv sync --extra dev
```

--------------------------------

### Install dependencies

Source: https://github.com/getzep/zep/blob/main/zep-eval-harness/README.md

Install the uv package manager and project dependencies.

```bash
# Install uv (macOS/Linux)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install dependencies
uv sync
```

--------------------------------

### Run Personal Assistant Example

Source: https://github.com/getzep/zep/blob/main/integrations/livekit/python/README.md

Command to execute the voice assistant example script.

```bash
# examples/voice_assistant.py
python examples/voice_assistant.py
```

--------------------------------

### Run Knowledge Assistant Example

Source: https://github.com/getzep/zep/blob/main/integrations/livekit/python/README.md

Command to execute the graph-based voice assistant example script.

```bash
# examples/graph_voice_assistant.py
python examples/graph_voice_assistant.py
```

--------------------------------

### Run AutoGen Examples

Source: https://github.com/getzep/zep/blob/main/integrations/autogen/python/SETUP.md

Execute the basic example script using either the repository environment or a pip-installed package.

```bash
uv run python examples/autogen_basic.py
```

```bash
python examples/autogen_basic.py
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/getzep/zep/blob/main/examples/python/elevenlabs-zep-example/llm-proxy/README.md

Install the required Python packages for the proxy server.

```bash
# From the project root
source venv/bin/activate
pip install fastapi uvicorn openai zep-cloud python-dotenv
```

--------------------------------

### Install zep-strands

Source: https://github.com/getzep/zep/blob/main/integrations/strands/python/README.md

Install the package via pip.

```bash
pip install zep-strands
```

--------------------------------

### Run React Agent Example

Source: https://github.com/getzep/zep/blob/main/integrations/langgraph/python/SETUP.md

Execute the React agent example using either uv or standard python.

```bash
uv run python examples/react_agent.py
```

```bash
python examples/react_agent.py
```

--------------------------------

### Install Dependencies

Source: https://github.com/getzep/zep/blob/main/examples/python/chunking-example/README.md

Install the required Python packages for the project.

```bash
pip install -r requirements.txt
```

--------------------------------

### Initialize and use ZepStore

Source: https://github.com/getzep/zep/blob/main/integrations/langgraph/python/README.md

Demonstrates initializing ZepStore with a backing store and performing asynchronous put, get, and search operations.

```python
from zep_langgraph import ZepStore

store = ZepStore(zep)                  # default backing store: InMemoryStore
await store.aput(("memories", "user-1"), "m1", {"text": "Alice works at Acme."})
item = await store.aget(("memories", "user-1"), "m1")     # exact-key, synchronous
hits = await store.asearch(("memories", "user-1"), query="where does Alice work?")
```

--------------------------------

### Install Zep Integration Packages

Source: https://github.com/getzep/zep/blob/main/integrations/ms-agent-framework/python/SETUP.md

Install the required packages using pip or set up the development environment using uv.

```bash
pip install zep-ms-agent-framework agent-framework-openai
```

```bash
git clone https://github.com/getzep/zep.git
cd zep/integrations/ms-agent-framework/python
make install        # uv sync --extra dev (includes agent-framework-openai)
```

--------------------------------

### Install for Local Development

Source: https://github.com/getzep/zep/blob/main/integrations/ag2/python/SETUP.md

Installs the package for local development using uv.

```bash
make install   # uv sync --extra dev
```

--------------------------------

### Install dependencies

Source: https://github.com/getzep/zep/blob/main/examples/python/autogen-agent/agent.ipynb

Install the required packages for Autogen and Zep integration.

```bash
pip install autogen zep-cloud
```

--------------------------------

### Run Development Server

Source: https://github.com/getzep/zep/blob/main/examples/typescript/zep-graph-visualization/README.md

Start the local development server to view the application.

```bash
npm run dev
# or
yarn dev
# or
pnpm dev
```

--------------------------------

### Run Basic AG2 Example

Source: https://github.com/getzep/zep/blob/main/integrations/ag2/python/SETUP.md

Executes the basic AG2 example script to verify the integration.

```bash
python examples/ag2_basic.py
```

--------------------------------

### Install Dependencies

Source: https://github.com/getzep/zep/blob/main/examples/typescript/langgraph/README.md

Install the required project dependencies using npm.

```bash
npm install
```

--------------------------------

### Initialize Test Data

Source: https://github.com/getzep/zep/blob/main/examples/python/elevenlabs-zep-example/llm-proxy/README.md

Run the setup script to populate Zep with test user data.

```bash
python setup_test_user.py
```

--------------------------------

### Run with Environment Variables

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/README.md

Directly export the API key and start the server.

```bash
export ZEP_API_KEY=your-zep-api-key-here
./zep-mcp-server
```

--------------------------------

### Install Proxy Dependencies

Source: https://github.com/getzep/zep/blob/main/examples/python/elevenlabs-zep-example/README.md

Install the required Python packages for the proxy server.

```bash
pip install fastapi uvicorn openai zep-cloud python-dotenv
```

--------------------------------

### Start the CLI Agent

Source: https://github.com/getzep/zep/blob/main/examples/typescript/langgraph/README.md

Launch the CLI agent using the npm start command.

```bash
npm start
```

--------------------------------

### Install Dependencies

Source: https://github.com/getzep/zep/blob/main/benchmarks/longmemeval/zep_memgpt_eval.ipynb

Install the required Zep and OpenAI Python packages.

```python
!pip install zep-cloud openai --upgrade
```

--------------------------------

### Clone and install from repository

Source: https://github.com/getzep/zep/blob/main/integrations/adk/typescript/SETUP.md

Use these commands to work on the package directly from a local repository checkout.

```bash
git clone https://github.com/getzep/zep.git
cd zep/integrations/adk/typescript
npm install
```

--------------------------------

### Install dependencies

Source: https://github.com/getzep/zep/blob/main/examples/python/langgraph-agent/agent.ipynb

Install the required packages for the Zep LangGraph agent.

```shell
pip install zep-cloud langchain-openai langgraph ipywidgets
```

--------------------------------

### Install dependencies

Source: https://github.com/getzep/zep/blob/main/integrations/vercel-ai/typescript/SETUP.md

Install the Zep integration package along with required peer dependencies.

```bash
npm install @getzep/zep-vercel-ai @getzep/zep-cloud ai zod
```

```bash
npm install @ai-sdk/openai
```

--------------------------------

### Start Proxy Server

Source: https://github.com/getzep/zep/blob/main/examples/python/elevenlabs-zep-example/llm-proxy/README.md

Launch the proxy server locally on port 8080.

```bash
python proxy_server.py
```

--------------------------------

### Install Zep LiveKit dependencies

Source: https://github.com/getzep/zep/blob/main/integrations/livekit/python/SETUP.md

Install the required package using pip or set up the development environment using uv.

```bash
pip install zep-livekit
```

```bash
git clone https://github.com/getzep/zep.git
cd zep/integrations/livekit/python
make install        # uv sync --extra dev
```

--------------------------------

### Install Zep LangGraph package

Source: https://github.com/getzep/zep/blob/main/integrations/langgraph/python/README.md

Install the required library via pip.

```bash
pip install zep-langgraph
```

--------------------------------

### Build and Install Zep MCP Server

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/README.md

Commands to clone the repository and build the server binary from source.

```bash
# Clone the repository
git clone https://github.com/getzep/zep.git
cd zep/mcp/zep-mcp-server

# Build the server
go build -o zep-mcp-server cmd/server/main.go

# Or install directly
go install github.com/getzep/zep/mcp/zep-mcp-server/cmd/server@latest
```

--------------------------------

### Install Zep AutoGen

Source: https://github.com/getzep/zep/blob/main/integrations/autogen/python/SETUP.md

Install the required package using pip or set up the development environment using uv.

```bash
pip install zep-autogen
```

```bash
git clone https://github.com/getzep/zep.git
cd zep/integrations/autogen/python
make install        # uv sync --extra dev
```

--------------------------------

### Troubleshoot container startup

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/docs/DOCKER.md

Commands to inspect logs and verify environment configuration when a container fails to start.

```bash
docker-compose logs
```

```bash
docker-compose config
```

--------------------------------

### Install zep-crewai package

Source: https://github.com/getzep/zep/blob/main/integrations/crewai/python/SETUP.md

Install the integration package using pip.

```bash
pip install zep-crewai
```

--------------------------------

### GitHub Actions CI/CD

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/docs/DOCKER.md

Example workflow steps for building, testing, and pushing the Docker image.

```yaml
- name: Build Docker image
  run: docker build -t zep-mcp-server:${{ github.sha }} .

- name: Run tests
  run: docker run zep-mcp-server:${{ github.sha }} make test

- name: Push to registry
  run: |
    docker tag zep-mcp-server:${{ github.sha }} registry/zep-mcp-server:latest
    docker push registry/zep-mcp-server:latest
```

--------------------------------

### Retrieve User Information Example

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/docs/TOOLS.md

Example input for the get_user tool to fetch user profile metadata.

```json
{
  "user_id": "alice_123"
}
```

--------------------------------

### Install Zep-AG2 Integration

Source: https://github.com/getzep/zep/blob/main/integrations/ag2/python/SETUP.md

Installs the integration package along with required runtime dependencies.

```bash
pip install zep-ag2
```

--------------------------------

### Install Locomo dependencies

Source: https://github.com/getzep/zep/blob/main/benchmarks/locomo/README.md

Use the uv package manager to install project dependencies.

```bash
# Install uv (if not already installed)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install dependencies
make install

# Or manually
uv sync
```

--------------------------------

### User Manifest Example

Source: https://github.com/getzep/zep/blob/main/zep-eval-harness/README.md

Example JSON manifest for a user ingestion run, including ontology and custom instruction settings.

```json
{
  "run_number": 1,
  "type": "users",
  "timestamp": "2026-03-31T22:24:36.839291",
  "ontology": {
    "type": "custom",
    "default_ontology_disabled": true,
    "custom_entity_types": ["Person", "Location", "Organization", "Event", "Item"],
    "custom_edge_types": ["RELATED_TO", "LOCATED_AT", "WORKS_FOR", "OWNS", "SCHEDULED_AT", "INVOLVES"]
  },
  "custom_instructions": {
    "enabled": true,
    "instruction_names": ["real_estate_domain", "property_and_location", "household_context"]
  },
  "user_summary_instructions": {
    "enabled": true,
    "instruction_names": ["property_requirements", "budget_and_finances", "location_preferences", "household_composition", "work_and_lifestyle"]
  },
  "users": [
    {
      "base_user_id": "zep_eval_test_user_001",
      "zep_user_id": "zep_eval_test_user_001_3f701979",
      "first_name": "Sarah",
      "last_name": "Chen",
      "thread_ids": ["conv_002_3f701979", "conv_001_3f701979"],
      "num_conversations": 2,
      "num_telemetry_files": 1
    }
  ]
}
```

--------------------------------

### Start Zep MCP Server

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/docs/DOCKER.md

Commands to initiate the server in the background or with active logging.

```bash
docker-compose up -d
```

```bash
docker-compose up
```

--------------------------------

### Start Services with Docker Compose

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/docs/DOCKER.md

Launch the Zep MCP Server using the provided docker-compose configuration.

```bash
docker-compose up
```

--------------------------------

### Install Zep Pydantic AI

Source: https://github.com/getzep/zep/blob/main/integrations/pydantic-ai/python/SETUP.md

Install the package using pip or set up the development environment using uv.

```bash
pip install zep-pydantic-ai
```

```bash
git clone https://github.com/getzep/zep.git
cd zep/integrations/pydantic-ai/python
make install        # uv sync --extra dev
```

--------------------------------

### Install Zep dependencies

Source: https://github.com/getzep/zep/blob/main/examples/python/quickstart/quickstart.ipynb

Install the required Python packages for Zep Cloud and OpenAI integration.

```bash
pip install zep-cloud openai rich python-dotenv
```

--------------------------------

### Provisioning with ZepMemoryManager

Source: https://github.com/getzep/zep/blob/main/integrations/ag2/python/README.md

Initializes a ZepMemoryManager instance with user identity and an optional on_created hook for one-time setup.

```python
async def setup_new_user(zep, user_id: str) -> None:
    await zep.user.add_ontology(user_id=user_id, ...)  # example one-time setup

manager = ZepMemoryManager(
    zep,
    user_id="user123",
    session_id="session456",
    first_name="Jane",
    last_name="Smith",
    email="jane@example.com",
    on_created=setup_new_user,
)
```

--------------------------------

### Install Zep Ingestion Package

Source: https://github.com/getzep/zep/blob/main/ingestion/SETUP.md

Install the core package and optional dependencies for LLM contextualization.

```bash
pip install zep-ingest
# optional, for LLM contextualization of chunked documents:
pip install "zep-ingest[anthropic]"   # and/or "zep-ingest[openai]"
```

--------------------------------

### Install Zep ADK for Go

Source: https://github.com/getzep/zep/blob/main/integrations/adk/go/SETUP.md

Add the Zep ADK module to your Go project.

```bash
go get github.com/getzep/zep/integrations/adk/go@latest
```

--------------------------------

### Run the Eve agent

Source: https://github.com/getzep/zep/blob/main/examples/typescript/eve/README.md

Starts the Eve local TUI for development and testing.

```bash
npm run dev
```

--------------------------------

### Install Zep Vercel AI dependencies

Source: https://github.com/getzep/zep/blob/main/integrations/vercel-ai/typescript/README.md

Install the required packages including Zep, Vercel AI SDK, and Zod.

```bash
npm install @getzep/zep-vercel-ai @getzep/zep-cloud ai zod
```

--------------------------------

### Install Zep ADK dependencies

Source: https://github.com/getzep/zep/blob/main/integrations/adk/typescript/SETUP.md

Install the required Zep and Google ADK packages in your project.

```bash
npm install @getzep/zep-adk @google/adk @getzep/zep-cloud
```

--------------------------------

### Create Search Graph Tools

Source: https://github.com/getzep/zep/blob/main/integrations/autogen/python/README.md

Examples of creating search tools with different parameter pinning and hiding configurations for AutoGen.

```python
# Expose everything to the model (default)
tool = create_search_graph_tool(zep_client, user_id="user_123")

# Pin scope and limit -- hidden from the model, always sent as given
tool = create_search_graph_tool(
    zep_client,
    user_id="user_123",
    pinned_params={"scope": "nodes", "limit": 5},
)

# Hide mmr_lambda from the schema without pinning it -- Zep's own default applies
tool = create_search_graph_tool(
    zep_client, user_id="user_123", hidden_params={"mmr_lambda"}
)
```

--------------------------------

### Run voice assistant example

Source: https://github.com/getzep/zep/blob/main/integrations/livekit/python/SETUP.md

Execute the voice assistant agent worker using the configured environment.

```bash
uv run python examples/voice_assistant.py dev
```

--------------------------------

### Retrieve User Context Example

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/docs/TOOLS.md

Example input for the get_user_context tool to fetch conversation-relevant facts and entities.

```json
{
  "thread_id": "conversation_456",
  "template_id": "my_custom_template"
}
```

--------------------------------

### Document Manifest Example

Source: https://github.com/getzep/zep/blob/main/zep-eval-harness/README.md

Example JSON manifest for a document ingestion run, detailing graph IDs and chunk counts.

```json
{
  "run_number": 1,
  "type": "documents",
  "timestamp": "2026-03-31T22:25:00.282382",
  "graph_id": "zep_eval_shared_documents_1d4d9a28",
  "num_chunks": 10,
  "ontology": {
    "type": "custom",
    "custom_entity_types": ["Concept", "Topic", "Process", "Specification", "Component"],
    "custom_edge_types": ["DESCRIBES", "DEPENDS_ON", "PART_OF", "REFERENCES", "IMPLEMENTS"]
  },
  "custom_instructions": {
    "enabled": true,
    "instruction_names": ["real_estate_reference_domain", "home_buying_process", "financial_concepts"]
  }
}
```

--------------------------------

### Implement One-Time User Setup

Source: https://github.com/getzep/zep/blob/main/integrations/adk/typescript/README.md

Use the onCreated hook within ensureUser to perform one-time setup tasks for new users.

```typescript
await ensureUser(zep, {
  userId,
  firstName,
  lastName,
  onCreated: async (zep, userId) => {
    // one-time setup: ontology, custom instructions, summary instructions, ...
  },
});
```

--------------------------------

### Document Chunking Process Output

Source: https://github.com/getzep/zep/blob/main/examples/python/chunking-example/README.md

Example console output showing the document chunking, contextualization, and ingestion process.

```text
============================================================
DOCUMENT CHUNKING WITH CONTEXTUALIZED RETRIEVAL
============================================================
Document: sample_document.txt
User ID: user123
Chunk size: 6000
Chunk overlap: 200
Dry run: False

Reading document: sample_document.txt
Document size: 15,432 characters

Chunking document (chunk_size=6000, overlap=200)...
Created 4 chunks

Processing chunks:
------------------------------------------------------------

Chunk 1/4 (5,842 chars)
  Contextualizing with OpenAI...
  Context: "This chunk covers the introduction and company values..."
  Ingesting to Zep...
  Created episode: ep_abc123...

...

============================================================
PROCESSING SUMMARY
============================================================
Total chunks: 4
Successfully processed: 4
Failed: 0
Original document size: 15,432 characters
Total contextualized size: 16,890 characters
Size expansion from contextualization: 9.4%
============================================================
```

--------------------------------

### Install Mastra Zep dependencies

Source: https://github.com/getzep/zep/blob/main/integrations/mastra/typescript/SETUP.md

Install the required Zep Mastra packages and the Mastra core peer dependency.

```bash
npm install @getzep/zep-mastra @getzep/zep-cloud @mastra/core
```

--------------------------------

### Development Environment Commands

Source: https://github.com/getzep/zep/blob/main/integrations/strands/python/README.md

Commands for installing dependencies and running development tasks like linting and testing.

```bash
cd integrations/strands/python
make install      # uv sync --extra dev
make all          # format + lint + type-check + test
```

--------------------------------

### Initialize Zep and OpenAI Clients

Source: https://github.com/getzep/zep/blob/main/benchmarks/longmemeval/zep_memgpt_eval.ipynb

Set up the asynchronous clients for Zep and OpenAI.

```python
zep = AsyncZep(
    api_key=os.getenv("ZEP_API_KEY"),
    base_url="https://api.development.getzep.com/api/v2",
)
oai_client = AsyncOpenAI(
    api_key=os.getenv("OPENAI_API_KEY"),
)
```

--------------------------------

### Initialize Zep ADK Client and Agent

Source: https://github.com/getzep/zep/blob/main/integrations/adk/go/README.md

Demonstrates initializing the Zep client, provisioning users and threads, and configuring the LLM agent with Zep callbacks.

```go
zep := zepadk.NewClientFromEnv() // nil when ZEP_API_KEY is unset -> no-op

// Provision the Zep user and thread out of band, before the first turn --
// e.g. during account/session onboarding. Both calls are idempotent.
created, _ := zepadk.EnsureUser(ctx, zep, userID, "Jane", "Smith", "jane@example.com")
if created {
    // One-time per-user setup goes here (ontology, custom instructions, etc.).
}
zepadk.EnsureThread(ctx, zep, sessionID, userID)

agent, _ := llmagent.New(llmagent.Config{
    Name:                 "assistant",
    Model:                llm, // a model.LLM, e.g. gemini.NewModel(...)
    BeforeModelCallbacks: []llmagent.BeforeModelCallback{zepadk.NewBeforeModelCallback(zep)},
    AfterModelCallbacks:  []llmagent.AfterModelCallback{zepadk.NewAfterModelCallback(zep)},
    Tools:                []tool.Tool{searchTool}, // from zepadk.NewGraphSearchTool(zep)
})

run, _ := runner.New(runner.Config{
    AppName:        "my_app",
    Agent:          agent,
    SessionService: sessions,
    MemoryService:  zepadk.NewMemoryService(zep),
})
```

--------------------------------

### CLI Agent Command-Line Options

Source: https://github.com/getzep/zep/blob/main/examples/typescript/langgraph/README.md

Examples of various command-line arguments supported by the agent for customization and debugging.

```bash
# Get help
npm start -- --help

# Basic usage with user ID
npm start -- --userId john_doe

# Using kebab-case format
npm start -- --user-id john_doe --thread-id vacation_planning

# Customize the system message
npm start -- --system-message "You are a travel assistant helping with vacation planning."

# Enable debug mode
npm start -- --debug
```

--------------------------------

### Configure and Run with .env

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/README.md

Steps to set up environment variables using a .env file and execute the server.

```bash
cp .env.example .env
```

```bash
ZEP_API_KEY=your-zep-api-key-here
LOG_LEVEL=info
```

```bash
./zep-mcp-server
```

--------------------------------

### Update user creation hooks

Source: https://github.com/getzep/zep/blob/main/integrations/adk/python/README.md

Pass the setup hook directly to ensure_user instead of the ZepContextTool constructor.

```python
# Before (0.2.x)
ZepContextTool(zep_client=zep, on_user_created=my_setup_hook)

# After (0.3.0+)
await ensure_user(zep, user_id=user_id, on_created=my_setup_hook)
```

--------------------------------

### FastAPI Integration Pattern

Source: https://github.com/getzep/zep/blob/main/integrations/livekit/python/CLAUDE.md

Example showing the separation between FastAPI room/token creation and the LiveKit agent worker process.

```python
# FastAPI creates room and tokens
@app.post("/create-room/{user_id}")
async def create_voice_session(user_id: str, user_name: str):
    # Generate access token and room for user
    
# Separate agent worker process
async def entrypoint(ctx: agents.JobContext):
    # Per-user agent instantiation
    user_id = extract_from_room_context(ctx)
    agent = ZepUserAgent(zep_client=zep_client, user_id=user_id, ...)
```

--------------------------------

### Provisioning Zep User and Thread

Source: https://github.com/getzep/zep/blob/main/integrations/vercel-ai/typescript/README.md

Idempotently creates a Zep user and thread, optionally executing a one-time setup hook when a new user is created.

```ts
await ensureZepUserAndThread({
  client,
  userId: "u1",
  threadId: "t1",
  firstName: "Jane",
  onUserCreated: async (zep, userId) => {
    // e.g. seed an initial graph fact or send a welcome event for this user.
    await zep.graph.add({ userId, type: "text", data: "New user onboarded." });
  },
});
```

--------------------------------

### Development Workflow Commands

Source: https://github.com/getzep/zep/blob/main/integrations/adk/typescript/README.md

Use these commands to manage dependencies, verify types, run tests, build the project, and execute examples.

```bash
npm install
npm run typecheck   # tsc --noEmit (NodeNext + strict)
npm test            # vitest (mocked @getzep/zep-cloud)
npm run build       # tsup → dist (ESM + .d.ts)
npm run example     # run examples/basic-agent.ts
```

--------------------------------

### Install Zep Pydantic AI

Source: https://github.com/getzep/zep/blob/main/integrations/pydantic-ai/python/README.md

Install the required package via pip.

```bash
pip install zep-pydantic-ai
```

--------------------------------

### Develop Python Integration Packages

Source: https://github.com/getzep/zep/blob/main/integrations/README.md

Commands to install dependencies, run tests, and build a Python-based integration package.

```bash
cd integrations/<framework>/python
uv sync --extra dev      # install (dev extras)
uv run pytest            # test
uv build                 # build
```

--------------------------------

### Start ElevenLabs Session with SDK

Source: https://github.com/getzep/zep/blob/main/examples/python/elevenlabs-zep-example/llm-proxy/README.md

Pass user and conversation identifiers via the ElevenLabs SDK to enable Zep context retrieval.

```javascript
const conversation = await Conversation.startSession({
    agentId: 'your_agent_id',
    // Pass user_id and conversation_id via customLlmExtraBody
    // This gets forwarded as "elevenlabs_extra_body" to your proxy
    customLlmExtraBody: {
        user_id: 'your-zep-user-id',
        conversation_id: 'your-zep-conversation-id'
    }
});
```

--------------------------------

### Configure Zep User and Session with Fact Rating

Source: https://github.com/getzep/zep/blob/main/examples/python/autogen-agent/agent.ipynb

Initializes a Zep user and session, applying a custom fact rating instruction to guide memory importance.

```python
bot_name = "CareBot"
user_name = "Cathy"

user_id = user_name + str(uuid.uuid4())[:4]
session_id = str(uuid.uuid4())


await zep.user.add(user_id=user_id)

fact_rating_instruction = """Rate the facts by poignancy. Highly poignant 
facts have a significant emotional impact or relevance to the user. 
Low poignant facts are minimally relevant or of little emotional 
significance."""
fact_rating_examples = FactRatingExamples(
    high="The user received news of a family member's serious illness.",
    medium="The user completed a challenging marathon.",
    low="The user bought a new brand of toothpaste.",
)

await zep.memory.add_session(
    user_id=user_id,
    session_id=session_id,
    fact_rating_instruction=FactRatingInstruction(
        instruction=fact_rating_instruction,
        examples=fact_rating_examples,
    ),
)
```

--------------------------------

### Initialize Zep and OpenAI clients

Source: https://github.com/getzep/zep/blob/main/examples/python/quickstart/quickstart.ipynb

Import necessary libraries and initialize the Zep and OpenAI clients using environment variables.

```python
import os
import json
import uuid

from openai import OpenAI
import rich

from dotenv import load_dotenv
from zep_cloud.client import Zep
from zep_cloud import Message

load_dotenv()

zep = Zep(api_key=os.environ.get("ZEP_API_KEY"))

oai_client = OpenAI(
    api_key=os.getenv("OPENAI_API_KEY"),
)
```

--------------------------------

### Configure Graph Search Tool Parameters

Source: https://github.com/getzep/zep/blob/main/integrations/adk/go/README.md

Demonstrates how to initialize the Graph Search Tool with different parameter configurations, including fully open, pinned, and hidden parameters.

```go
// Fully open: the model chooses scope, reranker, limit, mmr_lambda, and
// center_node_uuid for every call.
tool, _ := zepadk.NewGraphSearchTool(zep)

// Pin scope and limit; leave reranker/mmr_lambda/center_node_uuid exposed.
tool, _ := zepadk.NewGraphSearchTool(zep,
    zepadk.WithToolSearchScope(zep.GraphSearchScopeNodes),
    zepadk.WithToolSearchLimit(5),
)

// Hide mmr_lambda and center_node_uuid without pinning them to a value
// (useful when the reranker is never "mmr" or "node_distance").
tool, _ := zepadk.NewGraphSearchTool(zep,
    zepadk.WithHiddenParams(zepadk.SearchParamMMRLambda, zepadk.SearchParamCenterNodeUUID),
)
```

--------------------------------

### Provisioning Users and Threads

Source: https://github.com/getzep/zep/blob/main/integrations/crewai/python/CHANGELOG.md

Shows how to use ensure_user and ensure_thread for explicit provisioning before initializing storage adapters.

```python
from zep_crewai import ensure_user, ensure_thread

ensure_user(zep_client, user_id="user-1", first_name="Jane", email="jane@example.com")
ensure_thread(zep_client, thread_id="thread-1", user_id="user-1")

storage = ZepUserStorage(client=zep_client, user_id="user-1", thread_id="thread-1")
```

--------------------------------

### Provisioning Zep and Wiring Callbacks

Source: https://github.com/getzep/zep/blob/main/integrations/adk/typescript/README.md

Initializes the Zep client, provisions users and threads, and configures the LlmAgent with Zep callbacks.

```ts
import { LlmAgent } from "@google/adk";
import { ZepClient } from "@getzep/zep-cloud";
import { createZepCallbacks, ensureUser, ensureThread } from "@getzep/zep-adk";

const zep = new ZepClient({ apiKey: process.env.ZEP_API_KEY! });

// Provision once, e.g. during account/session onboarding — NOT on every turn.
await ensureUser(zep, {
  userId: "user-123",
  firstName: "Jane",
  lastName: "Smith",
  email: "jane@example.com",
});
await ensureThread(zep, { threadId: "thread-abc", userId: "user-123" });

// createZepCallbacks builds the before/after pair sharing one dedup guard —
// the recommended way to wire both callbacks together.
const { beforeModelCallback, afterModelCallback } = createZepCallbacks(zep, {
  userId: "user-123",
  threadId: "thread-abc",
  firstName: "Jane",
  lastName: "Smith",
});

const agent = new LlmAgent({
  name: "memory_agent",
  model: "gemini-2.5-flash",
  instruction: "You are a helpful assistant with long-term memory.",
  beforeModelCallback,
  afterModelCallback,
});
```

--------------------------------

### Setting up ZepGraphAgent

Source: https://github.com/getzep/zep/blob/main/integrations/livekit/python/README.md

Initialize a Zep client and ZepGraphAgent to enable shared knowledge graph access within a LiveKit session.

```python
from zep_livekit import ZepGraphAgent

async def entrypoint(ctx: agents.JobContext):
    # Initialize Zep client
    zep_client = AsyncZep(api_key=os.getenv("ZEP_API_KEY"))
    
    # Create or get knowledge graph
    graph_id = "company_knowledge_base"
    try:
        await zep_client.graph.get(graph_id)
    except:
        await zep_client.graph.create(
            graph_id=graph_id,
            name="Company Knowledge Base",
            description="Shared knowledge across all conversations"
        )
    
    # Connect to room
    await ctx.connect()
    
    # Create session
    session = agents.AgentSession(
        stt=openai.STT(),
        llm=openai.LLM(model="gpt-5-mini"),
        tts=openai.TTS(),
        vad=silero.VAD.load(),
    )
    
    # Create knowledge-enabled agent
    agent = ZepGraphAgent(
        zep_client=zep_client,
        graph_id=graph_id,
        user_name="Alice",  # Optional: for message attribution
        facts_limit=15,     # Max facts to retrieve
        entity_limit=5,     # Max entities to retrieve
        episode_limit=3,    # Max episodes to retrieve
        instructions="""
            You have access to a shared knowledge graph. 
            Store important facts for future reference and 
            search your knowledge to answer questions accurately.
        """
    )
    
    await session.start(agent=agent, room=ctx.room)
```

--------------------------------

### Initialize ZepGraphSearchTool with various configurations

Source: https://github.com/getzep/zep/blob/main/integrations/adk/typescript/README.md

Demonstrates how to instantiate the tool with fully dynamic, partially pinned, or fully restricted parameter configurations.

```ts
// Fully dynamic: the model chooses scope, reranker, limit, mmrLambda, centerNodeUuid.
new ZepGraphSearchTool({ zep, userId: "user-123" });

// Pin scope + limit, but let the model choose the reranker.
new ZepGraphSearchTool({ zep, userId: "user-123", scope: "edges", limit: 5 });

// Restore the pre-0.2.0 behavior: model only ever sees `query`.
new ZepGraphSearchTool({
  zep,
  userId: "user-123",
  scope: "edges",
  reranker: "rrf",
  limit: 10,
  mmrLambda: null,
  centerNodeUuid: null,
});
```

--------------------------------

### Initialize Zep Client

Source: https://github.com/getzep/zep/blob/main/examples/python/autogen-agent/agent.ipynb

Configure the Zep client using an API key.

```python
from zep_cloud.client import AsyncZep
from zep_cloud import Message, FactRatingExamples, FactRatingInstruction

MIN_FACT_RATING = 0.3

# Configure Zep
zep = AsyncZep(api_key=os.environ.get("ZEP_API_KEY"))
```

--------------------------------

### Initialize ZepMemoryStore with Standalone Graph

Source: https://github.com/getzep/zep/blob/main/integrations/strands/python/README.md

Use this configuration for shared domain knowledge; supports search and add operations only.

```python
ZepMemoryStore(zep_client=zep, graph_id="company-kb", writable=True, extraction=False)
```

--------------------------------

### Initialize Agent with Tools and Streaming

Source: https://github.com/getzep/zep/blob/main/integrations/autogen/python/README.md

Configures an AssistantAgent with tools and uses the Console to visualize tool execution streams.

```python

agent = AssistantAgent(
    name="Assistant",
    model_client=model_client,
    tools=[search_tool],
    reflect_on_tool_use=True, 
)

# Use streaming console for tool visualization
await Console(agent.run_stream(task="Search for Python information"))
```

--------------------------------

### Initialize Async Zep Client

Source: https://github.com/getzep/zep/blob/main/examples/python/langgraph-agent/agent.ipynb

Initialize the asynchronous Zep client using the API key from environment variables.

```python
from zep_cloud import Message
from zep_cloud.client import AsyncZep

zep = AsyncZep(api_key=os.environ.get("ZEP_API_KEY"))
```

--------------------------------

### Build Server

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/README.md

Commands for building the server for various platforms.

```bash
# Build for current platform
go build -o zep-mcp-server cmd/server/main.go

# Build for multiple platforms
GOOS=darwin GOARCH=arm64 go build -o zep-mcp-server-darwin-arm64 cmd/server/main.go
GOOS=darwin GOARCH=amd64 go build -o zep-mcp-server-darwin-amd64 cmd/server/main.go
GOOS=linux GOARCH=amd64 go build -o zep-mcp-server-linux-amd64 cmd/server/main.go
GOOS=windows GOARCH=amd64 go build -o zep-mcp-server-windows-amd64.exe cmd/server/main.go
```

--------------------------------

### Get Episodes

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/README.md

Retrieve recent data ingestion events for a user.

```javascript
// Get recent data ingestion events
tools.get_episodes({
  user_id: "user_123",
  lastn: 5
})
```

--------------------------------

### Initialize ZepMemoryStore with Strands Agent

Source: https://github.com/getzep/zep/blob/main/integrations/strands/python/README.md

Configure the Zep client, ensure user and thread existence, and attach the ZepMemoryStore to a Strands Agent.

```python
from strands import Agent
from strands.memory import MemoryManager
from zep_cloud.client import AsyncZep
from zep_strands import ZepMemoryStore, ensure_thread, ensure_user

zep = AsyncZep(api_key="your-api-key")

await ensure_user(
    zep,
    user_id="user-123",
    first_name="Jane",
    last_name="Smith",
    email="jane@example.com",
)
await ensure_thread(zep, thread_id="thread-abc", user_id="user-123")

store = ZepMemoryStore(
    zep_client=zep,
    user_id="user-123",
    thread_id="thread-abc",
    first_name="Jane",
    last_name="Smith",
    writable=True,
    extraction=True,  # server-side via add_messages
)

agent = Agent(
    system_prompt="You are a helpful assistant with long-term memory.",
    memory_manager=MemoryManager(stores=[store]),
)
```

--------------------------------

### Clone the Repository

Source: https://github.com/getzep/zep/blob/main/examples/typescript/zep-graph-visualization/README.md

Initial step to download the project source code.

```bash
git clone https://github.com/getzep/zep-graph-visualization.git
cd zep-graph-visualization
```

--------------------------------

### Get Thread Context

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/README.md

Retrieve context for a specific conversation thread.

```javascript
// Retrieve context for a conversation
tools.get_user_context({
  thread_id: "thread_456",
  template_id: "my_template"  // optional custom template
})
```

--------------------------------

### Initialize ZepMemoryStore with User Graph

Source: https://github.com/getzep/zep/blob/main/integrations/strands/python/README.md

Use this configuration for conversational agents by providing user and thread identifiers.

```python
ZepMemoryStore(zep_client=zep, user_id="user-123", thread_id="thread-abc", ...)
```

--------------------------------

### Enter Shell Environment

Source: https://github.com/getzep/zep/blob/main/examples/python/openai-agents-sdk/README.md

Activate the virtual environment shell.

```bash
uv shell
```

```bash
poetry shell
```

--------------------------------

### Initialize Autogen configuration

Source: https://github.com/getzep/zep/blob/main/examples/python/autogen-agent/agent.ipynb

Set up the environment and configuration list for the Autogen agent.

```python
import os
from dotenv import load_dotenv
import uuid
from typing import Union, Dict
from autogen import ConversableAgent, Agent

load_dotenv()

config_list = [
    {
        "model": "gpt-4o-mini",
        "api_key": os.environ.get("OPENAI_API_KEY"),
        "max_tokens": 1024,
    }
]
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/getzep/zep/blob/main/integrations/adk/go/SETUP.md

Set the required API keys for Zep and Google Gemini.

```bash
export ZEP_API_KEY="your-zep-api-key"
export GOOGLE_API_KEY="your-google-api-key"
```

--------------------------------

### Initiate agent conversation

Source: https://github.com/getzep/zep/blob/main/examples/python/autogen-agent/agent.ipynb

Uses the a_initiate_chat method to start a multi-turn conversation between agents.

```python
result = await agent.a_initiate_chat(
    cathy,
    message="Hi Cathy, nice to see you again. How are you doing today?",
    max_turns=3,
)
```

--------------------------------

### Configure Zep Search Tools

Source: https://github.com/getzep/zep/blob/main/integrations/vercel-ai/typescript/README.md

Demonstrates how to initialize the Zep search tool with default settings versus pinning or hiding specific search parameters from the model.

```ts
// Model chooses scope/reranker/limit/mmrLambda/centerNodeUuid (new default).
const tool = createZepSearchTool({ client, binding: { userId: "u1" } });

// Restore the pre-0.2.0 "model only sees query" behavior.
const pinnedTool = createZepSearchTool({
  client,
  binding: { userId: "u1" },
  pinnedParams: { scope: "edges", limit: 10 },
  hiddenParams: ["reranker", "mmrLambda", "centerNodeUuid"],
});
```

--------------------------------

### Development Commands

Source: https://github.com/getzep/zep/blob/main/integrations/langgraph/python/README.md

Standard commands for setting up the development environment and running quality checks.

```bash
git clone https://github.com/getzep/zep.git
cd zep/integrations/langgraph/python
make install      # uv sync --extra dev
make format       # ruff format .
make lint         # ruff check .
make type-check   # mypy src/
make test         # pytest tests/ -v
make all          # all of the above
make build        # uv build
```

--------------------------------

### Explicit User and Thread Provisioning

Source: https://github.com/getzep/zep/blob/main/integrations/ag2/python/CHANGELOG.md

Shows how to manually provision users and threads before initializing the ZepMemoryManager for explicit control.

```python
from zep_ag2 import ensure_user, ensure_thread

await ensure_user(zep_client, user_id="user-1", first_name="Jane", email="jane@example.com")
await ensure_thread(zep_client, thread_id="thread-1", user_id="user-1")

manager = ZepMemoryManager(zep_client, user_id="user-1", session_id="thread-1")
```

--------------------------------

### Run development and build commands

Source: https://github.com/getzep/zep/blob/main/ingestion/README.md

Use these commands to synchronize the development environment and execute the full suite of quality checks.

```bash
make install   # uv sync --extra dev
make all       # format + lint + type-check + test
```

--------------------------------

### Expose Search Tool via ZepContextProvider

Source: https://github.com/getzep/zep/blob/main/integrations/ms-agent-framework/python/README.md

Automatically build and register the search tool during ZepContextProvider initialization.

```python
provider = ZepContextProvider(
    zep_client=zep,
    user_id="user-123",
    thread_id="thread-abc",
    expose_search_tool=True,
    search_pinned_params={"scope": "nodes", "limit": 5},
)
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/getzep/zep/blob/main/integrations/ag2/python/SETUP.md

Commands to set up environment configuration files and export required API keys.

```bash
cp .env.example .env
```

```bash
# Required
export ZEP_API_KEY="your-zep-cloud-api-key"

# Required for examples that call an LLM
export OPENAI_API_KEY="your-openai-api-key"
```

--------------------------------

### Provisioning users and threads

Source: https://github.com/getzep/zep/blob/main/integrations/langgraph/python/CHANGELOG.md

New optional helper functions to ensure user and thread existence before the first interaction.

```python
from zep_langgraph import ensure_thread, ensure_user

await ensure_user(zep, user_id="user-1", first_name="Jane", email="jane@example.com")
await ensure_thread(zep, thread_id="thread-1", user_id="user-1")
```

--------------------------------

### Create a user and session

Source: https://github.com/getzep/zep/blob/main/examples/python/quickstart/quickstart.ipynb

Register a new user in Zep and initialize a chat session for them.

```python
bot_name = "SupportBot"

user_name = "Emily"
user_id = user_name + str(uuid.uuid4())[:4]
session_id = str(uuid.uuid4())

zep.user.add(
    user_id=user_id,
    email=f"{user_name}@painters.com",
    first_name=user_name,
    last_name="Painter",
)

zep.memory.add_session(
    user_id=user_id,
    session_id=session_id,
)
```

--------------------------------

### Provisioning Users and Threads

Source: https://github.com/getzep/zep/blob/main/integrations/livekit/python/README.md

Use ensure_user and ensure_thread for explicit, idempotent resource creation. The on_created callback allows for one-time initialization logic for new users.

```python
from zep_livekit import ensure_thread, ensure_user

async def seed_new_user(zep_client, user_id: str) -> None:
    """Runs exactly once, right after the user is first created."""
    ...  # seed initial facts, set custom instructions, configure ontology, etc.

created = await ensure_user(
    zep_client,
    user_id="user_123",
    first_name="Alice",
    on_created=seed_new_user,  # fires only for a genuinely new user
)
await ensure_thread(zep_client, thread_id="conversation_456", user_id="user_123")
```

--------------------------------

### Retrieve Conversation Memory

Source: https://github.com/getzep/zep/blob/main/examples/python/quickstart/quickstart.ipynb

Get context relevant to the current conversation and a list of prior messages for a session.

```python
memory = zep.memory.get(session_id=session_id)
rich.print(memory.context)
```

--------------------------------

### Retrieve user nodes example

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/docs/TOOLS.md

JSON payload for requesting entity nodes from a user's knowledge graph.

```json
{
  "user_id": "alice_123",
  "limit": 10
}
```

--------------------------------

### Initialize ZepUserAgent with LiveKit

Source: https://github.com/getzep/zep/blob/main/integrations/livekit/python/README.md

Sets up a Zep client, creates a user and thread, and initializes a memory-enabled agent within a LiveKit job context.

```python
import os
from livekit import agents
from livekit.plugins import openai, silero
from zep_cloud.client import AsyncZep
from zep_livekit import ZepUserAgent

async def entrypoint(ctx: agents.JobContext):
    # Initialize Zep client
    zep_client = AsyncZep(api_key=os.getenv("ZEP_API_KEY"))
    
    # Create user and thread
    user_id = "user_123"
    thread_id = f"conversation_{user_id}"
    
    try:
        await zep_client.user.get(user_id=user_id)
    except:
        await zep_client.user.add(user_id=user_id, first_name="Alice")
    
    await zep_client.thread.create(thread_id=thread_id, user_id=user_id)
    
    # Connect to room
    await ctx.connect()
    
    # Create session with providers
    session = agents.AgentSession(
        stt=openai.STT(),
        llm=openai.LLM(model="gpt-5-mini"),
        tts=openai.TTS(),
        vad=silero.VAD.load(),
    )
    
    # Create memory-enabled agent
    agent = ZepUserAgent(
        zep_client=zep_client,
        user_id=user_id,
        thread_id=thread_id,
        instructions="You are a helpful assistant with persistent memory."
    )
    
    # Start conversation with memory
    await session.start(agent=agent, room=ctx.room)
```

--------------------------------

### Retrieve node edges by UUID

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/docs/TOOLS.md

Use this tool to get all relationships and facts connected to a specific graph node.

```json
{
  "node_uuid": "550e8400-e29b-41d4-a716-446655440000"
}
```

--------------------------------

### Retrieve user episodes example

Source: https://github.com/getzep/zep/blob/main/mcp/zep-mcp-server/docs/TOOLS.md

JSON payload for requesting temporal events from a user's knowledge graph history.

```json
{
  "user_id": "alice_123",
  "lastn": 5
}
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/getzep/zep/blob/main/examples/python/chunking-example/README.md

Set the necessary API keys in your .env file.

```text
ZEP_API_KEY=your_zep_api_key
OPENAI_API_KEY=your_openai_api_key
```

--------------------------------

### Run Tests

Source: https://github.com/getzep/zep/blob/main/integrations/langgraph/python/SETUP.md

Execute the mock-based test suite.

```bash
make test
```