Zep

https://help.getzep.com/
Admin
Zep is a memory layer for AI assistants and agents that continuously learns from user interactions...
Tokens:277,823
Snippets:1,851
Trust Score:8.4
Update:3 months ago
Show doc for...
Tokens:
Raw
### Quick start zepctl commands

Source: https://help.getzep.com/docs/developer-tools/zepctl-cli

Configure a profile, verify the connection, and list users to get started.

```bash
# Configure your API key (you will be prompted to enter it securely)
zepctl config add-profile production

# Verify connection
zepctl project get

# List users
zepctl user list
```

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

### Install Zep SDK for Go

Source: https://help.getzep.com/quick-start-guide

Install the Zep Go package using go get.

```bash
go get github.com/getzep/zep-go/v3
```

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

### Get User Nodes SDK Examples

Source: https://help.getzep.com/sdk-reference/graph/node/get-user-nodes

Implementation examples for retrieving user nodes using the Zep SDK across different programming languages.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.graph.node.getByUserId("user_id", {});
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.graph.node.get_by_user_id(
    user_id="user_id",
)
```

```go
package example

import (
    context "context"

    zep "github.com/getzep/zep-go"
    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    request := &zep.GraphNodesRequest{}
    client.Graph.Node.GetByUserID(
        context.TODO(),
        "user_id",
        request,
    )
}
```

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

### Install dependencies

Source: https://help.getzep.com/graphiti/integrations/lang-graph-agent

Install the required packages for Graphiti, LangChain, and LangGraph.

```shell
pip install graphiti-core langchain-openai langgraph ipywidgets
```

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

### SDK Examples for Listing Custom Instructions

Source: https://help.getzep.com/sdk-reference/graph/custom-instructions/list-custom-instructions

Implementation examples for the TypeScript, Python, and Go SDKs.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.graph.listCustomInstructions({});
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.graph.list_custom_instructions()
```

```go
package example

import (
    context "context"

    zep "github.com/getzep/zep-go"
    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    request := &zep.GraphListCustomInstructionsRequest{}
    client.Graph.ListCustomInstructions(
        context.TODO(),
        request,
    )
}
```

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

### Install Dependencies

Source: https://help.getzep.com/chunking-large-documents

Install the necessary Zep, OpenAI, and environment variable packages for your project.

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

```bash
npm install @getzep/zep-cloud openai dotenv
```

```bash
go get github.com/getzep/zep-go/v2 github.com/sashabaranov/go-openai github.com/joho/godotenv
```

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

### SDK Examples for Retrieving Project Information

Source: https://help.getzep.com/sdk-reference/project/retrieves-project-information

Client-side implementation examples for TypeScript, Python, and Go.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.project.get();
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.project.get()
```

```go
package example

import (
    context "context"

    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    client.Project.Get(
        context.TODO(),
    )
}
```

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

### Install Graphiti with Kuzu support

Source: https://help.getzep.com/graphiti/configuration/kuzu-db-configuration

Install the core package with the Kuzu extra to enable the driver.

```bash
pip install graphiti-core[kuzu]
```

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

### Install Zep SDK

Source: https://help.getzep.com/give-your-agent-domain-knowledge

Commands to install the Zep SDK across different package managers.

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

```bash
uv pip install zep-cloud
```

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

```bash
yarn add @getzep/zep-cloud
```

```bash
pnpm install @getzep/zep-cloud
```

```bash
go get github.com/getzep/zep-go/v3
```

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

### Install Zep SDK for Python

Source: https://help.getzep.com/quick-start-guide

Install the Zep Python package using pip or uv.

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

```bash
uv pip install zep-cloud
```

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

### Install Zep and OpenAI Provider

Source: https://help.getzep.com/microsoft-agent-framework-memory

Install the Zep integration along with the OpenAI model provider.

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

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

### Install Graphiti Groq dependencies

Source: https://help.getzep.com/graphiti/configuration/llm-configuration

Install the necessary package to enable Groq support in Graphiti.

```bash
pip install "graphiti-core[groq]"
```

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

### SDK Usage Examples

Source: https://help.getzep.com/sdk-reference/graph/node/get-node

Implementation examples for retrieving a node using the TypeScript, Python, and Go SDKs.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.graph.node.get("uuid");
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.graph.node.get(
    uuid_="uuid",
)
```

```go
package example

import (
    context "context"

    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    client.Graph.Node.Get(
        context.TODO(),
        "uuid",
    )
}
```

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

### SDK Usage Examples

Source: https://help.getzep.com/sdk-reference/thread/get-threads

Examples of how to list threads using the TypeScript, Python, and Go SDKs.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.thread.listAll({
        pageNumber: 1,
        pageSize: 20,
        orderBy: "created_at",
        asc: false,
    });
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.thread.list_all(
    page_number=1,
    page_size=20,
    order_by="created_at",
    asc=False,
)
```

```go
package example

import (
    context "context"

    zep "github.com/getzep/zep-go"
    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    request := &zep.ThreadListAllRequest{
        PageNumber: zep.Int(
            1,
        ),
        PageSize: zep.Int(
            20,
        ),
        OrderBy: zep.String(
            "created_at",
        ),
        Asc: zep.Bool(
            false,
        ),
    }
    client.Thread.ListAll(
        context.TODO(),
        request,
    )
}
```

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

### Install Dependencies

Source: https://help.getzep.com/graphiti/configuration/aws-neptune-configuration

Install the Graphiti core package with Neptune support using pip or uv.

```bash
pip install graphiti-core[neptune]
```

```bash
uv add graphiti-core[neptune]
```

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

### Install Svix Library

Source: https://help.getzep.com/webhooks

Commands to install the required Svix client library for different programming environments.

```bash
pip install svix
```

```bash
npm install svix
```

```bash
go get github.com/svix/svix-webhooks/go
```

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

### Clone the user summary example repository

Source: https://help.getzep.com/user-summary-instructions

Use these commands to download the example project for user summary instructions.

```bash
git clone https://github.com/getzep/zep.git
cd zep/examples/python/user-summary-instructions-example
```

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

### Get Graph Request and Response Examples

Source: https://help.getzep.com/sdk-reference/graph/get-graph

Example JSON payloads for the request and the successful response of the Get Graph operation.

```json
{}
```

```json
{
  "created_at": "2024-06-10T09:45:00Z",
  "description": "Sales performance data for Q2 2024",
  "graph_id": "graph-9f8b7c6d",
  "id": 1024,
  "name": "Q2 Sales Overview",
  "project_uuid": "a3f1c9e2-7b4d-4f6a-9c3e-2d5f7b8a1c9e",
  "time_zone": "America/New_York",
  "uuid": "b7e23f2e-8c4a-4d1f-9a2b-3c5d7e8f9a0b"
}
```

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

### Install dependencies and configure environment

Source: https://help.getzep.com/evaluate-zep-for-your-use-case

Sync project dependencies and prepare the environment configuration file.

```bash
uv sync
```

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

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

### Clone and navigate to the Zep example repository

Source: https://help.getzep.com/quick-start-guide

Use these commands to download the official Python agent memory example and enter the project directory.

```bash
git clone https://github.com/getzep/zep.git
cd zep/examples/python/agent-memory-full-example
```

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

### Add User Instructions SDK Examples

Source: https://help.getzep.com/sdk-reference/user/add-user-instructions

Implementation examples for adding user summary instructions using TypeScript, Python, and Go SDKs.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.user.addUserSummaryInstructions({
        instructions: [
            {
                name: "Highlight Key Metrics",
                text: "Emphasize the most important performance indicators in the user summary.",
            },
        ],
    });
}
main();
```

```python
from zep_cloud import Zep, UserInstruction

client = Zep()

client.user.add_user_summary_instructions(
    instructions=[
        UserInstruction(
            name="Highlight Key Metrics",
            text="Emphasize the most important performance indicators in the user summary.",
        )
    ],
)
```

```go
package example

import (
    context "context"

    zep "github.com/getzep/zep-go"
    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    request := &zep.AddUserInstructionsRequest{
        Instructions: []*zep.UserInstruction{
            &zep.UserInstruction{
                Name: "Highlight Key Metrics",
                Text: "Emphasize the most important performance indicators in the user summary.",
            },
        },
    }
    client.User.AddUserSummaryInstructions(
        context.TODO(),
        request,
    )
}
```

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

### Get Observation SDK Examples

Source: https://help.getzep.com/sdk-reference/graph/observations/get-observation

Implementation examples for retrieving an observation using the TypeScript, Python, and Go SDKs.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.graph.observation.get("uuid");
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.graph.observation.get(
    uuid_="uuid",
)
```

```go
package example

import (
    context "context"

    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    client.Graph.Observation.Get(
        context.TODO(),
        "uuid",
    )
}
```

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

### Define example interactions

Source: https://help.getzep.com/evaluate-zep-for-your-use-case

Provide sample user-agent interactions to guide the generation of evaluation data.

```text
1. User: "What is my dog's name?"
   Agent: "Max"

2. User: "When is my vet appointment?"
   Agent: "Friday at Dr. Peterson's clinic"

3. User: "What training classes did I sign up for?"
   Agent: "Puppy training classes at PetSmart, Saturdays at 9am"
```

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

### Initialize and use ZepStore

Source: https://help.getzep.com/langgraph-memory

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?")
```

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

### SDK Implementation for Get User

Source: https://help.getzep.com/sdk-reference/user/get

Examples of how to retrieve a user using the TypeScript, Python, and Go SDKs.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.user.get("userId");
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.user.get(
    user_id="userId",
)
```

```go
package example

import (
    context "context"

    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    client.User.Get(
        context.TODO(),
        "userId",
    )
}
```

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

### Initialize Zep client, user, and thread

Source: https://help.getzep.com/how-to-share-context-across-users-using-graphs

Setup the Zep client and create a new user and thread to begin managing shared context.

```python
# Initialize the Zep client
zep_client = Zep(api_key="YOUR_API_KEY")  # Ensure your API key is set appropriately

# Add one example user
user_id = uuid.uuid4().hex
zep_client.user.add(
    user_id=user_id,
    first_name="Alice",
    last_name="Smith",
    email="alice.smith@example.com"
)

# Create a new thread for the user
thread_id = uuid.uuid4().hex
zep_client.thread.create(
    thread_id=thread_id,
    user_id=user_id,
)
```

```typescript
import { ZepClient } from "@getzep/zep-cloud";
import { randomUUID } from "crypto";

// Initialize the Zep client
const zepClient = new ZepClient({ apiKey: "YOUR_API_KEY" });

// Add one example user
const userId = randomUUID().replace(/-/g, "");
await zepClient.user.add({
    userId: userId,
    firstName: "Alice",
    lastName: "Smith",
    email: "alice.smith@example.com"
});

// Create a new thread for the user
const threadId = randomUUID().replace(/-/g, "");
await zepClient.thread.create({
    threadId: threadId,
    userId: userId
});
```

```go
import (
    "context"
    "log"

    "github.com/getzep/zep-go/v3"
    "github.com/getzep/zep-go/v3/client"
    "github.com/getzep/zep-go/v3/option"
    "github.com/google/uuid"
)

// Initialize the Zep client
zepClient := client.NewClient(option.WithAPIKey("YOUR_API_KEY"))

// Add one example user
userId := uuid.New().String()
_, err := zepClient.User.Add(context.Background(), &zep.CreateUserRequest{
    UserID:    userId,
    FirstName: zep.String("Alice"),
    LastName:  zep.String("Smith"),
    Email:     zep.String("alice.smith@example.com"),
})
if err != nil {
    log.Fatalf("Error: %v", err)
}

// Create a new thread for the user
threadId := uuid.New().String()
_, err = zepClient.Thread.Create(context.Background(), &zep.CreateThreadRequest{
    ThreadID: threadId,
    UserID:   userId,
})
if err != nil {
    log.Fatalf("Error: %v", err)
}
```

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

### Initialize Graphiti Client

Source: https://help.getzep.com/graphiti/integrations/lang-graph-agent

Setup the Graphiti client using environment variables or default local credentials.

```python
# Configure Graphiti

from graphiti_core import Graphiti
from graphiti_core.edges import EntityEdge
from graphiti_core.nodes import EpisodeType
from graphiti_core.utils.bulk_utils import RawEpisode
from graphiti_core.utils.maintenance.graph_data_operations import clear_data

neo4j_uri = os.environ.get('NEO4J_URI', 'bolt://localhost:7687')
neo4j_user = os.environ.get('NEO4J_USER', 'neo4j')
neo4j_password = os.environ.get('NEO4J_PASSWORD', 'password')

client = Graphiti(
    neo4j_uri,
    neo4j_user,
    neo4j_password,
)
```

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

### SDK Implementations for Get User Context

Source: https://help.getzep.com/sdk-reference/thread/get-user-context

Client-side SDK usage examples for TypeScript, Python, and Go.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.thread.getUserContext("threadId", {});
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.thread.get_user_context(
    thread_id="threadId",
)
```

```go
package example

import (
    context "context"

    zep "github.com/getzep/zep-go"
    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    request := &zep.ThreadGetUserContextRequest{}
    client.Thread.GetUserContext(
        context.TODO(),
        "threadId",
        request,
    )
}
```

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

### SDK Implementation for Get Task

Source: https://help.getzep.com/sdk-reference/task/get-task

Client-side implementation examples for retrieving a task in TypeScript, Python, and Go.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.task.get("task_id");
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.task.get(
    task_id="task_id",
)
```

```go
package example

import (
    context "context"

    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    client.Task.Get(
        context.TODO(),
        "task_id",
    )
}
```

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

### Install Dependencies

Source: https://help.getzep.com/graphiti/getting-started/mcp-server

Navigate to the MCP server directory and synchronize dependencies using uv.

```bash
cd mcp_server
uv sync
```

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

### Get Episode SDK Implementations

Source: https://help.getzep.com/sdk-reference/graph/episode/get-episode

Examples of how to retrieve an episode using the Zep SDKs in TypeScript, Python, and Go.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.graph.episode.get("uuid");
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.graph.episode.get(
    uuid_="uuid",
)
```

```go
package example

import (
    context "context"

    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    client.Graph.Episode.Get(
        context.TODO(),
        "uuid",
    )
}
```

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

### SDK Implementation for Get Batch

Source: https://help.getzep.com/sdk-reference/batch/get-batch

Examples showing how to retrieve a batch using the TypeScript, Python, and Go SDKs.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.batch.get("batchId");
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.batch.get(
    batch_id="batchId",
)
```

```go
package example

import (
    context "context"

    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    client.Batch.Get(
        context.TODO(),
        "batchId",
    )
}
```

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

### Create Batch SDK Implementations

Source: https://help.getzep.com/sdk-reference/batch/create-batch

Examples of how to initialize the client and trigger a batch creation in various programming languages.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.batch.create({});
}
main();

```

```python
from zep_cloud import Zep

client = Zep()

client.batch.create()

```

```go
package example

import (
    context "context"

    zep "github.com/getzep/zep-go"
    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    request := &zep.ApidataCreateBatchRequest{}
    client.Batch.Create(
        context.TODO(),
        request,
    )
}
```

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

### SDK Implementation for Get User Threads

Source: https://help.getzep.com/sdk-reference/user/get-user-threads

Examples of how to retrieve user threads using the TypeScript, Python, and Go SDKs.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.user.getThreads("userId");
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.user.get_threads(
    user_id="userId",
)
```

```go
package example

import (
    context "context"

    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    client.User.GetThreads(
        context.TODO(),
        "userId",
    )
}
```

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

### SDK Implementations for Get Graph

Source: https://help.getzep.com/sdk-reference/graph/get-graph

Client-side code examples for retrieving a graph using the TypeScript, Python, and Go SDKs.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.graph.get("graphId");
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.graph.get(
    graph_id="graphId",
)
```

```go
package example

import (
    context "context"

    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    client.Graph.Get(
        context.TODO(),
        "graphId",
    )
}
```

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

### SDK Implementation Examples

Source: https://help.getzep.com/sdk-reference/project/updates-project-time-zone-information

Demonstrates how to update project information using the Zep SDKs in TypeScript, Python, and Go.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.project.update({});
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.project.update()
```

```go
package example

import (
    context "context"

    zep "github.com/getzep/zep-go"
    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    request := &zep.UpdateProjectInfoRequest{}
    client.Project.Update(
        context.TODO(),
        request,
    )
}
```

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

### Get Graph Observations SDK Examples

Source: https://help.getzep.com/sdk-reference/graph/observations/get-graph-observations

Retrieve observations for a given graph ID using the TypeScript, Python, and Go SDKs.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.graph.observation.getByGraphId("graph_id", {});
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.graph.observation.get_by_graph_id(
    graph_id="graph_id",
)
```

```go
package example

import (
    context "context"

    zep "github.com/getzep/zep-go"
    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    request := &zep.GraphObservationsRequest{}
    client.Graph.Observation.GetByGraphID(
        context.TODO(),
        "graph_id",
        request,
    )
}
```

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

### Clone and Navigate Repository

Source: https://help.getzep.com/graphiti/getting-started/mcp-server

Initial steps to obtain the source code and enter the project directory.

```bash
git clone https://github.com/getzep/graphiti.git
cd graphiti
```

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

### Initialize Zep Client and Add User

Source: https://help.getzep.com/check-data-ingestion-status

Setup the Zep client and create a user to associate with graph data.

```python
import os
import uuid
import time
from dotenv import find_dotenv, load_dotenv
from zep_cloud.client import Zep

load_dotenv(dotenv_path=find_dotenv())

client = Zep(api_key=os.environ.get("ZEP_API_KEY"))
uuid_value = uuid.uuid4().hex[:4]
user_id = "-" + uuid_value
client.user.add(
    user_id=user_id,
    first_name = "John",
    last_name = "Doe",
    email="john.doe@example.com"
)
```

```typescript
import { ZepClient } from "@getzep/zep-cloud";
import * as dotenv from "dotenv";
import { v4 as uuidv4 } from 'uuid';

// Load environment variables
dotenv.config();

const client = new ZepClient({ apiKey: process.env.ZEP_API_KEY || "" });
const uuidValue = uuidv4().substring(0, 4);
const userId = "-" + uuidValue;

async function main() {
  // Add user
  await client.user.add({
    userId: userId,
    firstName: "John",
    lastName: "Doe",
    email: "john.doe@example.com"
  });
```

```go
package main

import (
	"context"
	"fmt"
	"os"
	"strings"
	"time"

	"github.com/getzep/zep-go/v3"
	zepclient "github.com/getzep/zep-go/v3/client"
	"github.com/getzep/zep-go/v3/option"
	"github.com/google/uuid"
	"github.com/joho/godotenv"
)

func main() {
	// Load .env file
	err := godotenv.Load()
	if err != nil {
		fmt.Println("Warning: Error loading .env file:", err)
		// Continue execution as environment variables might be set in the system
	}

	// Get API key from environment variable
	apiKey := os.Getenv("ZEP_API_KEY")
	if apiKey == "" {
		fmt.Println("ZEP_API_KEY environment variable is not set")
		return
	}

	// Initialize Zep client
	client := zepclient.NewClient(
		option.WithAPIKey(apiKey),
	)

	// Create a UUID
	uuidValue := strings.ToLower(uuid.New().String()[:4])

	// Create user ID
	userID := "-" + uuidValue

	// Create context
	ctx := context.Background()

	// Add a user
	userRequest := &zep.CreateUserRequest{
		UserID:    zep.String(userID),
		FirstName: zep.String("John"),
		LastName:  zep.String("Doe"),
		Email:     zep.String("john.doe@example.com"),
	}
	_, err = client.User.Add(ctx, userRequest)
	if err != nil {
		fmt.Printf("Error creating user: %v\n", err)
		return
	}
```

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

### Get Graph Edges SDK Implementation

Source: https://help.getzep.com/sdk-reference/graph/edge/get-graph-edges

Examples of how to retrieve graph edges using the Zep SDK in different programming languages.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.graph.edge.getByGraphId("graph_id", {});
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.graph.edge.get_by_graph_id(
    graph_id="graph_id",
)
```

```go
package example

import (
    context "context"

    zep "github.com/getzep/zep-go"
    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    request := &zep.GraphEdgesRequest{}
    client.Graph.Edge.GetByGraphID(
        context.TODO(),
        "graph_id",
        request,
    )
}
```

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

### Get Graph Episodes SDK Implementation

Source: https://help.getzep.com/sdk-reference/graph/episode/get-graph-episodes

Examples of how to retrieve graph episodes using the Zep SDK in various programming languages.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.graph.episode.getByGraphId("graph_id", {});
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.graph.episode.get_by_graph_id(
    graph_id="graph_id",
)
```

```go
package example

import (
    context "context"

    client "github.com/getzep/zep-go/client"
    graph "github.com/getzep/zep-go/graph"
)

func do() {
    client := client.NewClient()
    request := &graph.EpisodeGetByGraphIDRequest{}
    client.Graph.Episode.GetByGraphID(
        context.TODO(),
        "graph_id",
        request,
    )
}
```

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

### Configure Environment Variables

Source: https://help.getzep.com/graphiti/getting-started/mcp-server

Example configuration for LLM and database settings in a .env file.

```bash
# Required LLM Configuration
OPENAI_API_KEY=your_openai_api_key_here
MODEL_NAME=gpt-5-mini

# Database Configuration (FalkorDB is default, or use Neo4j)
# For FalkorDB (Redis-based):
# REDIS_HOST=localhost
# REDIS_PORT=6379
# REDIS_PASSWORD=your_redis_password

# For Neo4j:
NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=your_neo4j_password

# Optional: Disable telemetry
# GRAPHITI_TELEMETRY_ENABLED=false
```

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

### SDK Implementation Examples

Source: https://help.getzep.com/sdk-reference/graph/list-all-graphs

Demonstrates how to list all graphs using the TypeScript, Python, and Go SDKs.

```typescript
import { ZepClient } from "zep-cloud";

async function main() {
    const client = new ZepClient();
    await client.graph.listAll({});
}
main();
```

```python
from zep_cloud import Zep

client = Zep()

client.graph.list_all()
```

```go
package example

import (
    context "context"

    zep "github.com/getzep/zep-go"
    client "github.com/getzep/zep-go/client"
)

func do() {
    client := client.NewClient()
    request := &zep.GraphListAllRequest{}
    client.Graph.ListAll(
        context.TODO(),
        request,
    )
}
```

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

### Install Graphiti Core

Source: https://help.getzep.com/graphiti/configuration/llm-configuration

Install the core Graphiti package via pip.

```bash
pip install graphiti-core
```

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

### Initialize Clients

Source: https://help.getzep.com/chunking-large-documents

Initialize the OpenAI and Zep clients using environment variables.

```python
import os
from openai import OpenAI
from zep_cloud.client import Zep
from dotenv import load_dotenv

load_dotenv()

openai_client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
zep_client = Zep(api_key=os.environ.get("ZEP_API_KEY"))
```

```typescript
import { config } from "dotenv";
import { ZepClient } from "@getzep/zep-cloud";
import OpenAI from "openai";

config();

const openaiClient = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const zepClient = new ZepClient({ apiKey: process.env.ZEP_API_KEY });
```

```go
import (
    "os"

    "github.com/getzep/zep-go/v2"
    zepclient "github.com/getzep/zep-go/v2/client"
    "github.com/getzep/zep-go/v2/option"
    "github.com/joho/godotenv"
    openai "github.com/sashabaranov/go-openai"
)

godotenv.Load()

openaiClient := openai.NewClient(os.Getenv("OPENAI_API_KEY"))
zepClient := zepclient.NewClient(option.WithAPIKey(os.Getenv("ZEP_API_KEY")))
```

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

### Install Zep CrewAI package

Source: https://help.getzep.com/crewai-memory

Install the required library via pip.

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

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

### Install Zep AG2 package

Source: https://help.getzep.com/ag2-memory

Install the required package via pip.

```bash
pip install zep-ag2
```
Tokens:
Raw