Zep: End-to-End Context Engineering Platform

Examples, Integrations, & More

Zep is redefining how AI systems access and use the information they need to operate in the real world. By delivering context with sub-200ms latency, Zep solves the perennial agent context problem: how to assemble, maintain, and retrieve rich, up-to-date knowledge from diverse sources so AI agents can act with accuracy and reliability in production settings. This blog unfolds the core ideas, architecture, and practical guidance you’ll find in Zep’s documentation, SDKs, and repositories.

What is Zep? A Brief Overview

Zep is an end-to-end context engineering platform designed to deliver the right information at the right moment. It does this by pulling together context from multiple sources — chat history, business data, documents, and app events — and presenting it as structured, relationship-aware blocks that your AI agents can consume quickly. The result is agents that understand not only what happened, but how entities relate and how those relations evolve over time.

Key promises of Zep include:

• Sub-200ms latency for context delivery, enabling responsive agents in production workloads.
• Comprehensive, relationship-aware context that captures not just facts but their connections, dependencies, and temporal changes.
• Seamless integration with leading agent frameworks and data sources to assemble a complete, current picture for decision-making.

How Zep Works: The Three Core Stages

Zep’s workflow centers on three interconnected stages: add context, graph-based retrieval, and context assembly. Each stage is designed to be composable, scalable, and interpretable for developers and operators alike.

1) Add Context: Feeding the System

Context is generated as the world evolves. Zep ingests:

• Chat messages and chat histories, preserving the flow of conversations.
• Business data such as customer records, transactions, statuses, and workflows.
• Documents, metadata, and content from internal repositories.
• App events, signals from dashboards, triggers from workflows, and system logs.

This continuous intake ensures that the knowledge graph grows richer over time, capturing what happened, who was involved, and in what context.

The ingestion layer is designed to handle streaming data and batch updates, maintaining consistency even as new information arrives. By feeding context in near real-time, Zep minimizes stale information and keeps agents primed to act on the latest signals.

2) Graph RAG: Building and Maintaining the Temporal Knowledge Graph

At the heart of Zep is a temporal knowledge graph powered by Graphiti, a framework that models relationships and their evolution. As new context arrives, Zep:

• Extracts relationships between entities (for example, customer, product, order, and support ticket) and encodes them into a graph structure.
• Tracks temporal states using validat and invalidat timestamps, enabling agents to reason about how relationships and contexts have changed over time.
• Maintains a dynamic map of dependencies and affinities, such as which documents relate to which conversations, or how a policy affects a sequence of events.

This graph-based representation provides a robust foundation for contextual reasoning. It allows agents to understand not only static facts but also how those facts interact, evolve, and influence each other.

3) Retrieve & Assemble: Pre-formatted, Relationship-Aware Context Blocks

When an AI agent needs to decide, Zep retrieves the most relevant slices of the knowledge graph and associated data, then assembles them into ready-to-consume context blocks. These blocks are:

• Pre-formatted for compatibility with your chosen LLM or agent framework.
• Relationship-aware, highlighting connections, proximate events, and evolving context.
• Optimized to minimize token usage while maximizing informational value, ensuring fast response times even with large data sources.

The result is a disciplined, explainable pipeline where agents get timely, accurate, and context-rich information to guide decision-making and actions.

Getting Started with Zep

If you’re evaluating Zep for a real-world use case, here are the practical entry points and options you’ll encounter.

Sign up for Zep Cloud

Visit www.getzep.com to sign up for Zep Cloud, our managed service that delivers intelligent agent context with sub-200ms latency, enterprise-grade scalability, and SOC 2 Type 2 + HIPAA compliance. With Zep Cloud, you can begin assembling context for your agents and integrating with production systems with minimal overhead.

A quick reminder: Zep emphasizes speed and reliability, so you’ll often see a three-line pattern to add context assembly to your agents in code. The goal is to get you from sign-up to working context blocks as smoothly as possible.

Find Zep SDKs

To enable seamless integration, Zep ships SDKs for multiple languages. Install the client library that matches your tech stack:

• Python: pip install zep-cloud
• TypeScript/JavaScript: npm install @getzep/zep-cloud
• Go: go get github.com/getzep/zep-go/v2

These SDKs provide straightforward APIs to push context, query the knowledge graph, and fetch the pre-formatted blocks your agents consume.

Get Help

• Documentation: help.getzep.com
• Discord Community: Join our Discord
• Support: Access comprehensive guides and tutorials on the help site

The consolidated support channels ensure you have practical examples and troubleshooting resources as you experiment with context assembly and agent integrations.

About This Repository: A Work in Progress

This repository is a living collection of examples, integrations, and tools designed to illustrate how to build intelligent agent context with Zep. It’s intentionally a work in progress, inviting contributors to explore and extend.

• The repository showcases example applications that demonstrate agent context assembly with Zep.
• It contains integration packages for popular agent frameworks and code samples for a range of use cases.
• Development tools and utilities are included to streamline experimentation and learning.

If you’re curious about how Zep plays with established agent frameworks, you’ll find examples that pair Zep with LangChain, LlamaIndex, AutoGen, and other frameworks. These samples reveal practical patterns for deriving context from diverse sources and delivering it to agents in a production-friendly format.

Repository Structure

• Example applications demonstrating agent context assembly with Zep.
• Integration packages for popular agent frameworks.
• Code samples for different use cases.
• Development tools and utilities to accelerate experimentation.

Development Setup: Working with UV and Python Packages

Zep’s development workflow leans on UV (Astral’s UV) for Python package management, which provides workspace features and a robust development environment.

Prerequisites

• Python 3.13+
• UV package manager

Getting Started

1) Install UV (if not already installed):

• On macOS and Linux:
• curl -LsSf https://astral.sh/uv/install.sh | sh
• On Windows:
• powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

2) Sync the workspace:

• uv sync

3) Activate the virtual environment:

• On Unix/macOS:
• source .venv/bin/activate
• On Windows:
• .venv\Scripts\activate

Workspace Structure

The project is configured as a UV workspace with the following packages:

• Main package (zep): Core Zep functionality
• Autogen integration (integration/autogen/): Integration package for Autogen framework

Working with the Workspace

• Install dependencies: uv sync
• Add dependencies to the main package: uv add
• Add dependencies to autogen integration: uv add --project integration/autogen
• Run tests for autogen integration: uv run --project integration/autogen pytest
• Build packages: uv build

Integration Development

The Autogen integration package is organized as:

integration/autogen/ ├── src/zep_autogen/ # Package source code ├── tests/ # Test files └── pyproject.toml # Package configuration

This structure is representative of how Zep frames integrations with external frameworks, making it easier to experiment with different adapters while keeping core logic stable.

Graphiti: The Knowledge Graph Framework

Zep is powered by Graphiti, an open-source temporal knowledge graph framework that enables relationship-aware context retrieval. Graphiti autonomously builds and maintains knowledge graphs while reasoning about state changes over time. Each fact within the graph includes validat and invalidat dates, which allows agents to understand how relationships, preferences, and context have evolved—providing a richer, more accurate basis for decision-making in dynamic environments.

Key advantages of Graphiti in Zep include:

• Temporal reasoning: Understanding when a relationship existed and when it changed.
• Relationship-rich context: Capturing how entities connect and influence each other.
• Explainability: Helping operators see why a particular context block was assembled for an agent’s decision.

If you want to dive deeper into the mechanics, you can explore the Graphiti repository to learn how the temporal knowledge graph is constructed and traversed to support context retrieval.

Community Edition (Legacy)

Note: Zep Community Edition is no longer supported. It has been deprecated and its code has been moved to the legacy/ folder in this repository. For current development and production use, Zep Cloud or the example projects within this repository are the recommended paths.

For those curious about the shift in strategy, the announcement blog details the rationale and方向 of Zep’s open-source evolution: announcing a new direction for Zep’s open-source strategy. This transition reflects a commitment to enterprise-grade capabilities, managed services, and a more cohesive ecosystem around context engineering.

Contributing

Open to contributions from the community. Contributions are welcome in areas such as:

• Code enhancements and new integrations
• Documentation improvements and tutorials
• Bug reports and feature requests
• Building additional example projects and demonstrations

If you’re considering contributing, please review the contributing guidelines in the CONTRIBUTING.md file. Clear steps exist for:

• Submitting code changes
• Proposing documentation updates
• Reporting issues and requests for enhancements
• Participating in community examples and integrations

Your participation helps advance Zep’s ecosystem and accelerates adoption for teams building resilient AI agents.

Why Zep Matters: The Value of Context Engineering

In AI-powered environments, context is not a mere backdrop; it is the engine that powers accurate reasoning, faster responses, and safer actions. Zep’s context engineering approach provides several critical advantages:

• Consistent access to up-to-date information across sources, reducing hallucinations and stale results.
• Clear separation between raw data and assembled context, enabling safer governance and better auditing.
• Temporal understanding that captures how relationships and states evolve, which is essential for decision-making in dynamic settings (such as customer journeys, supply chains, or incident response).

By delivering richly connected context blocks that are ready for retrieval by LLMs and agents, Zep helps teams scale AI capabilities without sacrificing reliability or explainability.

Imagery and Identity: Visual Cues Within the Platform

The Zep brand and its ecosystem are often presented with a recognizable logo and social/interactive badges that point to the broader community. The platform’s visuals symbolize speed, reliability, and a robust approach to data-driven context. The Zep logo serves as a banner for the platform’s identity and is a recurring symbol in onboarding, documentation, and marketing assets.

• Zep Logo: A distinctive emblem used to anchor branding across the site and materials.
• Discord badge: A quick link to the community chat, where developers and users share tips, troubleshoot, and collaborate on use cases.
• Twitter badge: A doorway to updates, announcements, and thought leadership from the Zep team.

These visual cues, while simple, reinforce a collaborative mindset: fast feedback loops, active discussions, and a culture of open experimentation.

Practical Scenarios: Where Zep Shines

• Real-time customer support agents that need to know a customer’s history, current ticket status, and related documents without re-querying multiple systems.
• Compliance-aware AI assistants that must reason about policy changes and the temporal state of relationships between entities.
• Knowledge workers who want to augment decision-making with context that spans chat, documents, and system events, all formatted for immediate consumption by LLMs.
• Data teams building experiments with LangChain, LlamaIndex, AutoGen, and other frameworks, using Zep as the central context engine to unify disparate sources.

Getting the Most from Zep: Best Practices

• Model your data sources: Define how chat history, business data, documents, and app events map to entities in the knowledge graph. A well-modeled graph speeds retrieval and enhances interpretability.
• Embrace temporal reasoning: Think in terms of validat/invalidat when modeling relationships. This enables agents to distinguish between past, present, and transitional states.
• Use pre-formatted blocks: Leverage Zep’s retrieval to present context blocks that your LLMs can immediately consume, minimizing additional formatting work.
• Start with a minimal viable set: Begin with a small, well-defined integration and expand gradually, validating performance and correctness at each step.

The Path Forward: Open-Source and Enterprise Adoption

Zep’s journey has prioritized practical deployment, reliability, and scalable context management in production environments. The Graphiti-driven temporal knowledge graph is central to this capability, enabling robust relationship reasoning and evolution tracking that standard retrieval approaches can’t capture as effectively.

For teams evaluating open-source options, Zep’s approach offers concrete benefits: a cohesive context assembly pipeline, ready-to-use SDKs, and proven integration patterns with widely adopted agent frameworks. The ongoing emphasis on enterprise-grade compliance and performance makes Zep a compelling choice for organizations seeking to scale AI-powered workflows with confidence.

Final Thoughts

Zep represents a mature vision for context engineering: a system that does not merely fetch facts but constructs a coherent, evolving picture of the world that AI agents can reason about. With its temporal knowledge graph, relationship-aware retrieval, and practical developer tooling, Zep provides the scaffolding necessary to build reliable, scalable, and explainable AI agents in production.

If you’re ready to explore, sign up for Zep Cloud, review the SDKs for your language of choice, and dive into the example projects that demonstrate assembling agent context with LangChain, LlamaIndex, AutoGen, and more. The journey from data to actionable context begins with a single integration — and Zep is designed to make that path fast, clear, and repeatable.

Images from the Input

• Zep Logo: Zep Logo
• Discord and Twitter badges: the community-facing badges included in the header of this post

Note: The Community Edition has transitioned away from active support; current development emphasizes Zep Cloud and the open example projects within this repository. For more on this strategic shift, refer to the announcement blog linked earlier in this post.