Zep AI (YC W24)

We're #hiring a new Staff Engineer in San Francisco, California. Truly exciting times to be in the AI memory space. Come join us!

Zep just introduced a game-changing way for AI agents to remember and learn. Unlike other systems that only retrieve static documents, Zep uses a temporal knowledge graph to combine conversations and structured business data, keeping track of how things change over time. Here’s why it matters: > It’s more accurate: 94.8% on DMR (better than MemGPT’s 93.4%). > It’s faster: Cuts response time by 90%. > It handles complex tasks like remembering across sessions and reasoning over time. > Lower token costs, making it scalable and enterprise-ready. Read it here: https://fnf.dev/4ars9sP

Zep AI (YC W24) is the new state of the art in agent memory. It's a memory layer for AI agents that continuously learns from user interactions and changing business data. By providing agents with a complete, holistic view of each user, Zep enables developers to build applications that tackle complex, personalized tasks. In research published today, Zep demonstrated that it delivers up to 18.5% higher accuracy with 90% lower latency when compared to tools like MemGPT, excelling in both the Deep Memory Retrieval (DMR) and LongMemEval benchmarks. https://lnkd.in/gBhxW-_a

Big News Day: Zep is officially the state-of-the-art in AI agent memory. In research we're publishing today, we demonstrate that Zep outperforms the current state-of-the-art memory system, MemGPT (Letta AI), in the Deep Memory Retrieval (DMR) benchmark—the primary evaluation metric used by the Letta/MemGPT team. More significantly, Zep excels in the LongMemEval benchmark, a comprehensive and challenging chat history memory evaluation that better reflects real-world enterprise use cases. In this benchmark, Zep delivers aggregate accuracy improvements of up to 18.5%, with individual evaluations showing gains exceeding 100% compared to using the full chat transcript in the context window, all while reducing response latency by 90%. In short, these findings demonstrate that Zep is capable of offering rich context retrieval, even in the complex data scenarios faced by large enterprises. Read more here: https://buff.ly/4jlis35

Amazing article on building agents with memory. Also, check out that diagram! Woo 🚀

Knowledge graphs are huge for AI Agents! A knowledge graph is the difference between a dumb AI agent and one that blows everyone's mind. Agents need memory and must know how to keep it updated over time (This is difficult, and it's the main reason most agents you've seen get dumber overnight!) This is where a knowledge graph helps. A knowledge graph is a network of connected points, each representing a piece of information. It's a very efficient structure for capturing complex relationships between data. Google uses a (huge) knowledge graph as part of Search. (Probably the largest knowledge graph in the world.) It was arguably one of the best improvements to Search since it was created. For building AI agents, knowledge graphs have two advantages: 1. They make it easier to extract facts from memory 2. They make it easier to update facts as they change The second point is crucial: You want agents to keep up with the world and update old facts as they discover new information. Here is a recommendation that will teach you how to use a knowledge graph as the memory layer of an AI agent: Ken Collins wrote an excellent article in which he builds a chat history for Llama 3 using Zep AI (YC W24)'s AI Memory (backed by a knowledge graph.) Here is a link to the article: https://fnf.dev/4fPAXtx This article is a great example of how to build agents that keep up with change. Zep is an open-source library that will serve as your agent's memory. You can connect it to any agent framework, model, or platform. The article's source code is in TypeScript, but you can use Zep with Python or Go as well. In a few bullet points: 1. You send messages to your AI agent 2. Zep synthesizes the information into a knowledge graph 3. You can retrieve any relevant facts from memory extremely fast Thanks to the Zep team for sponsoring this post.

Zep Holiday Roundup: Explore User & Group Graphs, Fact Ratings, and SOC 2 Type 2 Certification! 🎄 🎁

Thanks for the shout out, Kesha Williams!

If you give a RAG agent chunks of space articles from 1994, it’ll tell you Pluto’s a planet. But what happens if you give it chunks of articles from 2004, and chunks from an article from 2024 that says Pluto is no longer a planet? The LLM might get confused, or bias towards the more frequent mention of Pluto being a planet. Vector databases have enabled AI agents to perform incredibly well at information retrieval. But RAG doesn’t do a great job of encoding time. Vector databases match for keyword and semantic relevance…not “How recent is this information?” or “Is this fact still valid?” Unless you design your system to account for this, you’ll get inaccurate results. That’s fine if time isn’t an issue for your AI agent. But if you’re designing an enterprise product that talks to users, it probably is: - Your customer support agent should know past issues your customers ran into - Your product recommendation agent should know the customer bought Nikes, then returned them because they “didn’t like them” - Your company docs agent should know you used to support Salesforce in v1, but deprecated support in v2 LLMs, surprisingly enough, do a great job understanding this. But they can only reason with the information they have, and if the vector database doesn't retrieve temporally relevant chunks, it doesn’t matter. Luckily, we solved this with Graphiti, Zep’s open-source graph library. DM if you’re interested in learning more.

I think all the hype around LLMs has caused us to overlook Small Language Models. Let me explain - you might actually realize you need them. We’re building the foundational memory later for AI agents. That means our customers expect low latency - no one wants to wait more than a few seconds for a response from an AI agent. Just imagine trying to build a sales bot that takes 15 seconds to answer your question. You’d just buy from somebody else. So the ability to do high-leverage tasks (like sales) quickly is extremely powerful. This is where smaller-language models can give you leverage. Fine-tuning for specific tasks and using accurate memory to ensure right data is provided can result in faster results and with the same accuracy as frontier models. Example models that come to mind: Microsoft Phi-3, Llama3.2 11B Just don’t feel like you have to throw the largest and most expensive model at a problem.