zep-livekit 0.1.0__py3-none-any.whl

zep_livekit/__init__.py

@@ -0,0 +1,11 @@
+"""
+Zep Memory integration for LiveKit.
+
+This module provides a memory-enabled agent that integrates Zep with LiveKit's voice AI framework.
+"""
+
+from .agent import ZepGraphAgent, ZepUserAgent
+from .exceptions import ZepLiveKitError
+
+__version__ = "0.1.0"
+__all__ = ["ZepUserAgent", "ZepGraphAgent", "ZepLiveKitError"]

zep_livekit/agent.py

@@ -0,0 +1,432 @@
+"""
+Zep user memory integration for LiveKit agents.
+
+This module provides the ZepUserAgent class that integrates Zep's memory capabilities
+with LiveKit's voice AI agent framework
+"""
+
+import asyncio
+import logging
+from typing import Any, Literal
+
+from livekit import agents
+from livekit.agents.llm.chat_context import ChatContext, ChatMessage
+from zep_cloud import SearchFilters
+from zep_cloud.client import AsyncZep
+from zep_cloud.graph.utils import compose_context_string
+from zep_cloud.types import Message, Reranker
+
+from .exceptions import AgentConfigurationError
+
+logger = logging.getLogger(__name__)
+
+
+class ZepUserAgent(agents.Agent):
+    """
+    LiveKit agent with Zep memory capabilities.
+
+    A drop-in replacement for LiveKit's Agent that adds persistent memory:
+    - Stores user and assistant messages in Zep threads
+    - Retrieves relevant context and injects it for personalized responses
+    - Accepts all standard LiveKit Agent parameters
+
+    Args:
+        zep_client: Initialized AsyncZep client for memory operations
+        user_id: User identifier for memory isolation and personalization
+        thread_id: Thread identifier for conversation continuity
+        user_message_name: Optional name to set on user messages in Zep
+        assistant_message_name: Optional name to set on assistant messages in Zep
+        **kwargs: All other LiveKit Agent parameters (chat_ctx, tools, stt, llm, tts, etc.)
+    """
+
+    def __init__(
+        self,
+        *,
+        zep_client: AsyncZep,
+        user_id: str,
+        thread_id: str,
+        context_mode: Literal["basic", "summary"] | None = None,
+        user_message_name: str | None = None,
+        assistant_message_name: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if not user_id:
+            raise AgentConfigurationError("user_id must be a non-empty string")
+        if not thread_id:
+            raise AgentConfigurationError("thread_id must be a non-empty string")
+
+        # Initialize base Agent with all parameters passed through
+        super().__init__(**kwargs)
+
+        self._zep_client = zep_client
+        self._user_id = user_id
+        self._thread_id = thread_id
+        self._context_mode = context_mode or "basic"
+        self._user_message_name = user_message_name
+        self._assistant_message_name = assistant_message_name
+
+    async def on_enter(self) -> None:
+        """Called when the agent enters a conversation."""
+        await super().on_enter()
+
+        # Hook into session events to capture assistant messages
+        if hasattr(self, "session"):
+            self._setup_session_handlers()
+
+    def _setup_session_handlers(self) -> None:
+        """Set up event handlers on the session to capture assistant responses."""
+
+        @self.session.on("conversation_item_added")
+        def on_conversation_item_added(event: Any) -> None:
+            """Handle conversation item addition events to capture assistant responses."""
+            # Schedule async storage to avoid blocking event processing
+            asyncio.create_task(self._handle_conversation_item(event))
+
+    async def _handle_conversation_item(self, event: Any) -> None:
+        """Handle conversation item from session event."""
+        try:
+            # Extract conversation item from event
+            if not hasattr(event, "item"):
+                return
+
+            item = event.item
+
+            # Validate item has required message attributes
+            if not (hasattr(item, "role") and hasattr(item, "content")):
+                return
+
+            role = item.role
+            content = item.content
+
+            # Only store assistant messages (user messages handled in on_user_turn_completed)
+            if role == "assistant":
+                content_text = self._extract_text_content(content)
+                if content_text.strip():
+                    await self._store_assistant_message(content_text.strip(), item)
+
+        except Exception as e:
+            logger.error(f"Failed to handle conversation item: {e}")
+
+    def _extract_text_content(self, content: Any) -> str:
+        """Extract text content from various LiveKit content formats."""
+        if isinstance(content, str):
+            return content
+
+        if isinstance(content, list):
+            text_parts = []
+            for item in content:
+                if hasattr(item, "text"):
+                    text_parts.append(item.text)
+                elif isinstance(item, str):
+                    text_parts.append(item)
+            return " ".join(text_parts)
+
+        return str(content)
+
+    async def _store_assistant_message(self, content_text: str, item: Any) -> None:
+        """Store assistant message in Zep thread memory."""
+        try:
+            # Use custom assistant name if provided, otherwise fallback to item name
+            message_name = self._assistant_message_name or getattr(item, "name", None)
+
+            zep_message = Message(content=content_text, role="assistant", name=message_name)
+
+            await self._zep_client.thread.add_messages(
+                thread_id=self._thread_id, messages=[zep_message]
+            )
+
+        except Exception as e:
+            logger.warning(f"Failed to store assistant response: {e}")
+
+    async def on_user_turn_completed(self, turn_ctx: ChatContext, new_message: ChatMessage) -> None:
+        """
+        Handle user turn completion - store message and inject memory context.
+
+        1. Store user message in Zep
+        2. Retrieve relevant context from Zep
+        3. Inject context into conversation
+        """
+        await super().on_user_turn_completed(turn_ctx, new_message)
+
+        user_text = new_message.text_content
+        if not user_text or not user_text.strip():
+            return
+
+        try:
+            zep_message = Message(
+                content=user_text.strip(), role="user", name=self._user_message_name
+            )
+
+            await self._zep_client.thread.add_messages(
+                thread_id=self._thread_id, messages=[zep_message]
+            )
+
+        except Exception as e:
+            logger.warning(f"Failed to store user message in Zep: {e}")
+
+        try:
+            memory_result = await self._zep_client.thread.get_user_context(
+                thread_id=self._thread_id, mode=self._context_mode
+            )
+
+            if memory_result and memory_result.context:
+                context = memory_result.context
+
+                turn_ctx.add_message(role="system", content=f"Relevant user context:\n{context}")
+
+        except Exception as e:
+            logger.warning(f"Failed to retrieve context from Zep: {e}")
+
+    async def on_exit(self) -> None:
+        """Called when the agent exits a conversation."""
+        await super().on_exit()
+
+
+class ZepGraphAgent(agents.Agent):
+    """
+    LiveKit agent with Zep graph memory capabilities.
+
+    A drop-in replacement for LiveKit's Agent that adds persistent knowledge storage:
+    - Stores user and assistant messages in Zep graph
+    - Performs hybrid search to retrieve relevant context from edges, nodes, and episodes
+    - Uses smart context composition for comprehensive knowledge retrieval
+    - Optional user name prefixing for message attribution
+
+    User Identification:
+    - If user_name is provided, messages are stored as "[UserName]: message" and "[Assistant]: response"
+    - If user_name is None, messages are stored without prefixes
+    - Designed for per-user agent instances (typical deployment pattern)
+
+    Args:
+        zep_client: Initialized AsyncZep client for memory operations
+        graph_id: Graph identifier for knowledge storage
+        user_name: Optional user name for message prefixing (e.g., "Alice", "Bob")
+        facts_limit: Maximum number of facts/edges to retrieve (default: 20)
+        entity_limit: Maximum number of entities/nodes to retrieve (default: 5)
+        episode_limit: Maximum number of episodes to retrieve (default: 3)
+        search_filters: Optional filters for graph search
+        reranker: Optional reranker for search results
+        **kwargs: All other LiveKit Agent parameters
+    """
+
+    def __init__(
+        self,
+        *,
+        zep_client: AsyncZep,
+        graph_id: str,
+        user_name: str | None = None,
+        facts_limit: int = 15,
+        entity_limit: int = 5,
+        episode_limit: int = 2,
+        search_filters: SearchFilters | None = None,
+        reranker: Reranker | None = "rrf",
+        **kwargs: Any,
+    ) -> None:
+        if not graph_id:
+            raise AgentConfigurationError("graph_id must be a non-empty string")
+
+        # Initialize base Agent with all parameters passed through
+        super().__init__(**kwargs)
+
+        self._zep_client = zep_client
+        self._graph_id = graph_id
+        self._user_name = user_name
+        self._facts_limit = facts_limit
+        self._entity_limit = entity_limit
+        self._episode_limit = episode_limit
+        self._search_filters = search_filters
+        self._reranker = reranker
+
+    async def on_enter(self) -> None:
+        """Called when the agent enters a conversation."""
+        await super().on_enter()
+
+        # Hook into session events to capture assistant messages
+        if hasattr(self, "session"):
+            self._setup_session_handlers()
+
+    def _setup_session_handlers(self) -> None:
+        """Set up event handlers on the session to capture assistant responses."""
+
+        @self.session.on("conversation_item_added")
+        def on_conversation_item_added(event: Any) -> None:
+            """Handle conversation item addition events to capture assistant responses."""
+            # Schedule async storage to avoid blocking event processing
+            asyncio.create_task(self._handle_conversation_item(event))
+
+    async def _handle_conversation_item(self, event: Any) -> None:
+        """Handle conversation item from session event."""
+        try:
+            # Extract conversation item from event
+            if not hasattr(event, "item"):
+                return
+
+            item = event.item
+
+            # Validate item has required message attributes
+            if not (hasattr(item, "role") and hasattr(item, "content")):
+                return
+
+            role = item.role
+            content = item.content
+
+            # Only store assistant messages (user messages handled in on_user_turn_completed)
+            if role == "assistant":
+                content_text = self._extract_text_content(content)
+                if content_text.strip():
+                    await self._store_assistant_message(content_text.strip(), item)
+
+        except Exception as e:
+            logger.error(f"Failed to handle conversation item: {e}")
+
+    def _extract_text_content(self, content: Any) -> str:
+        """Extract text content from various LiveKit content formats."""
+        if isinstance(content, str):
+            return content
+
+        if isinstance(content, list):
+            text_parts = []
+            for item in content:
+                if hasattr(item, "text"):
+                    text_parts.append(item.text)
+                elif isinstance(item, str):
+                    text_parts.append(item)
+            return " ".join(text_parts)
+
+        return str(content)
+
+    async def _store_assistant_message(self, content_text: str, item: Any) -> None:
+        """Store assistant message in Zep graph."""
+        try:
+            # Prefix assistant messages for consistency when user has a name
+            if self._user_name:
+                message_data = f"[Assistant]: {content_text}"
+            else:
+                message_data = content_text
+
+            await self._zep_client.graph.add(
+                graph_id=self._graph_id, type="message", data=message_data
+            )
+
+        except Exception as e:
+            logger.warning(f"Failed to store assistant response: {e}")
+
+    async def on_user_turn_completed(self, turn_ctx: ChatContext, new_message: ChatMessage) -> None:
+        """
+        Handle user turn completion - store message and inject memory context.
+
+        1. Store user message in Zep graph
+        2. Perform hybrid search to retrieve relevant context
+        3. Inject context into conversation using smart composition
+        """
+        await super().on_user_turn_completed(turn_ctx, new_message)
+
+        user_text = new_message.text_content
+        if not user_text or not user_text.strip():
+            return
+
+        # Step 1: Store user message in Zep graph with user identification
+        try:
+            # Prefix message with user name if provided
+            message_data = user_text.strip()
+            if self._user_name:
+                message_data = f"[{self._user_name}]: {message_data}"
+
+            await self._zep_client.graph.add(
+                graph_id=self._graph_id, type="message", data=message_data
+            )
+
+        except Exception as e:
+            logger.warning(f"Failed to store user message in Zep graph: {e}")
+
+        # Step 2: Retrieve relevant context using hybrid search
+        try:
+            context = await self._retrieve_graph_context(user_text[:400])  # Limit query length
+
+            if context:
+                # Step 3: Inject context as system message
+                turn_ctx.add_message(
+                    role="system", content=f"Relevant knowledge from memory:\n{context}"
+                )
+
+        except Exception as e:
+            logger.warning(f"Failed to retrieve context from Zep graph: {e}")
+
+    async def _retrieve_graph_context(self, query: str) -> str | None:
+        """
+        Retrieve and compose context from graph using hybrid search.
+
+        - Search for edges (facts), nodes (entities) and episodes concurrently
+        - Compose a context string using the graph utilities
+        """
+        try:
+            # Perform parallel searches like in autogen
+            search_functions = []
+
+            if self._facts_limit:
+                # Search for facts/relationships (edges)
+                search_functions.append(
+                    self._zep_client.graph.search(
+                        graph_id=self._graph_id,
+                        query=query,
+                        limit=self._facts_limit,
+                        search_filters=self._search_filters,
+                        reranker=self._reranker,
+                        scope="edges",
+                    ),
+                )
+
+            if self._entity_limit:
+                # Search for entities (nodes)
+                search_functions.append(
+                    self._zep_client.graph.search(
+                        graph_id=self._graph_id,
+                        query=query,
+                        limit=self._entity_limit,
+                        search_filters=self._search_filters,
+                        reranker=self._reranker,
+                        scope="nodes",
+                    ),
+                )
+
+            if self._episode_limit:
+                # Search for episodes
+                search_functions.append(
+                    self._zep_client.graph.search(
+                        graph_id=self._graph_id,
+                        query=query,
+                        limit=self._episode_limit,
+                        search_filters=self._search_filters,
+                        reranker=self._reranker,
+                        scope="episodes",
+                    ),
+                )
+
+            results = await asyncio.gather(*search_functions)
+
+            edges = []
+            nodes = []
+            episodes = []
+
+            # Collect all results
+            for result in results:
+                if result.edges:
+                    edges.extend(result.edges)
+                if result.nodes:
+                    nodes.extend(result.nodes)
+                if result.episodes:
+                    episodes.extend(result.episodes)
+
+            if not edges and not nodes and not episodes:
+                return None
+
+            context = compose_context_string(edges, nodes, episodes)
+            return context
+
+        except Exception as e:
+            logger.error(f"Error retrieving graph context: {e}")
+            return None
+
+    async def on_exit(self) -> None:
+        """Called when the agent exits a conversation."""
+        await super().on_exit()

zep_livekit/exceptions.py

@@ -0,0 +1,15 @@
+"""
+LiveKit-specific exceptions for Zep integration.
+"""
+
+
+class ZepLiveKitError(Exception):
+    """Base exception for Zep LiveKit integration errors."""
+
+    pass
+
+
+class AgentConfigurationError(ZepLiveKitError):
+    """Raised when agent configuration is invalid."""
+
+    pass

zep_livekit-0.1.0.dist-info/METADATA

@@ -0,0 +1,330 @@
+Metadata-Version: 2.4
+Name: zep-livekit
+Version: 0.1.0
+Summary: LiveKit integration for Zep
+Project-URL: Homepage, https://github.com/getzep/zep
+Project-URL: Documentation, https://help.getzep.com/integrations/livekit
+Project-URL: Repository, https://github.com/getzep/zep
+Project-URL: Bug Tracker, https://github.com/getzep/zep/issues
+Project-URL: Changelog, https://github.com/getzep/zep/blob/main/integrations/python/zep_livekit/CHANGELOG.md
+Requires-Python: >=3.10
+Requires-Dist: livekit-agents[openai,silero]>=1.0.0
+Requires-Dist: typing-extensions>=4.0.0
+Requires-Dist: zep-cloud>=3.4.3
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Zep LiveKit Integration
+
+Add persistent memory to your LiveKit voice agents with [Zep's](https://www.getzep.com) memory capabilities. This integration provides both conversational memory for user sessions and shared knowledge graphs for cross-session information storage.
+
+## Quick Start
+
+### Install Dependencies
+
+```bash
+pip install zep-livekit
+```
+
+### Environment Setup
+
+Configure your environment with the required API keys and LiveKit connection details:
+
+```bash
+# Required API keys
+export OPENAI_API_KEY="your-openai-api-key"
+export ZEP_API_KEY="your-zep-cloud-api-key"
+
+# LiveKit configuration
+export LIVEKIT_URL="your-livekit-url"
+export LIVEKIT_API_KEY="your-livekit-api-key" 
+export LIVEKIT_API_SECRET="your-livekit-api-secret"
+```
+
+## Memory Architecture
+
+Zep uses a unified temporal knowledge graph where all conversation data contributes to a single, dynamic graph structure. The LiveKit integration provides two complementary approaches to interact with this unified memory:
+
+### Thread-Based Memory Access (ZepUserAgent)
+- **Purpose**: Structured conversation history and contextual retrieval
+- **Storage**: Messages stored in threads that automatically contribute to the user's unified graph
+- **Retrieval**: Context blocks assembled with temporal information from the graph
+- **Use Case**: Personal assistants, customer support, tutoring sessions
+
+### Direct Graph Memory Access (ZepGraphAgent)  
+- **Purpose**: Direct interaction with the knowledge graph for shared information
+- **Storage**: Information stored directly as facts, entities, and relationships in the graph
+- **Retrieval**: Semantic search across the entire temporal knowledge graph
+- **Use Case**: Knowledge bases, collaborative assistants, information systems
+
+Both approaches work with the same underlying temporal knowledge graph - threads automatically enrich the graph with entities, relationships, and facts, while direct graph access allows for explicit knowledge management.
+
+## Thread-Based Memory Access
+
+Using structured conversation threads that automatically contribute to your unified graph:
+
+### Basic Setup
+
+```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-4o-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)
+```
+
+### Advanced Configuration
+
+```python
+# Enhanced user agent with message attribution
+agent = ZepUserAgent(
+    zep_client=zep_client,
+    user_id="user_123",
+    thread_id="conversation_456", 
+    context_mode="summary",  # or "basic"
+    user_message_name="Alice",  # Name for user messages in Zep
+    assistant_message_name="Assistant",  # Name for assistant messages
+    instructions="You remember our previous conversations and preferences."
+)
+```
+
+## Direct Graph Memory Access
+
+For explicit control over what gets stored as facts, entities, and relationships in your unified graph:
+
+### Basic Setup
+
+```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-4o-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)
+```
+
+
+## Querying Your Unified Graph
+
+### Thread-Based Context Retrieval
+
+```python
+# Get conversation context assembled from the unified graph
+memory_result = await zep_client.thread.get_user_context(
+    thread_id="conversation_123",
+    mode="basic"  # or "summary"
+)
+
+if memory_result and memory_result.context:
+    print(f"Context from unified graph: {memory_result.context}")
+```
+
+### Direct Graph Search
+
+```python
+# Search directly across the temporal knowledge graph
+search_results = await zep_client.graph.search(
+    graph_id="company_knowledge_base",
+    query="Python programming best practices",
+    limit=10,
+    scope="edges"  # facts, or "nodes" (entities), "episodes"
+)
+
+# Use Zep's utility to compose context
+from zep_cloud.graph.utils import compose_context_string
+context = compose_context_string(
+    search_results.edges,
+    search_results.nodes, 
+    search_results.episodes
+)
+```
+
+## Agent Comparison
+
+| Agent Type | Best For | Memory Access Method | Use Cases |
+|------------|----------|-------------------|-----------|
+| **ZepUserAgent** | Personal assistants | Thread-based access to unified graph | Conversation continuity, customer support, tutoring |
+| **ZepGraphAgent** | Knowledge systems | Direct graph access to unified graph | Shared information, collaborative assistants, knowledge bases |
+
+### When to Use Each
+
+**Use ZepUserAgent when:**
+- Building personal assistants with structured conversation flow
+- Need conversation history and context retrieval across sessions
+- Want automatic thread-to-graph ingestion without manual management
+- Prefer working with conversation-based memory access patterns
+
+**Use ZepGraphAgent when:**  
+- Building knowledge management systems with explicit fact storage
+- Need direct semantic search across the temporal knowledge graph
+- Want to manually control what information gets stored as facts
+- Building systems where information should be immediately searchable across entities
+
+## Complete Examples
+
+### Personal Assistant
+```bash
+# examples/voice_assistant.py
+python examples/voice_assistant.py
+```
+
+### Knowledge Assistant  
+```bash
+# examples/graph_voice_assistant.py
+python examples/graph_voice_assistant.py
+```
+
+## API Reference
+
+### ZepUserAgent
+
+```python
+class ZepUserAgent(agents.Agent):
+    def __init__(
+        self,
+        *,
+        zep_client: AsyncZep,
+        user_id: str,
+        thread_id: str,
+        context_mode: Literal["basic", "summary"] = "basic",
+        user_message_name: str | None = None,
+        assistant_message_name: str | None = None,
+        **kwargs: Any  # All LiveKit Agent parameters
+    )
+```
+
+### ZepGraphAgent
+
+```python
+class ZepGraphAgent(agents.Agent):
+    def __init__(
+        self,
+        *,
+        zep_client: AsyncZep,
+        graph_id: str,
+        user_name: str | None = None,
+        facts_limit: int = 15,
+        entity_limit: int = 5, 
+        episode_limit: int = 2,
+        search_filters: SearchFilters | None = None,
+        reranker: Reranker | None = "rrf",
+        **kwargs: Any  # All LiveKit Agent parameters
+    )
+```
+
+
+## Development
+
+### Setup Development Environment
+
+```bash
+git clone https://github.com/getzep/zep
+cd zep/integrations/python/zep_livekit
+make install
+```
+
+### Development Workflow
+
+```bash
+make format      # Format code with ruff
+make lint        # Run linting checks  
+make type-check  # Run MyPy type checking
+make test        # Run test suite
+make pre-commit  # Full pre-commit workflow
+make ci          # Strict CI-style checks
+```
+
+## Support
+
+### Zep Resources
+- 📖 [Zep Documentation](https://help.getzep.com)
+- 💬 [Zep Discord Community](https://discord.gg/W8xaHrqWVc)  
+- 🐛 [GitHub Issues](https://github.com/getzep/zep/issues)
+- 📧 [Email Support](mailto:support@getzep.com)
+
+### LiveKit Resources  
+- 📖 [LiveKit Documentation](https://docs.livekit.io)
+
+---
+
+Built with ❤️ by the [Zep](https://www.getzep.com) team.

zep_livekit-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+zep_livekit/__init__.py,sha256=AnfAn284Ov_OOJThgXyWZ8JF8FojrSgy8B_Ijp95tMo,318
+zep_livekit/agent.py,sha256=tcxCT7i7pl61N2sGRwR1zpVJOdXg7T6fIOlE0ZwjgRM,16269
+zep_livekit/exceptions.py,sha256=W1JAf3gTrRX-R8ozyEDDPN3SadlYujoEcBQmXVWKbjk,278
+zep_livekit-0.1.0.dist-info/METADATA,sha256=ck3rWQT8zuUzCNXOqJ_VQK_vdcIQL1cPlrpDlnn57zs,10129
+zep_livekit-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+zep_livekit-0.1.0.dist-info/RECORD,,

zep_livekit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any