📢 Announcing our research paper: Zentry achieves 26% higher accuracy than OpenAI Memory, 91% lower latency, and 90% token savings! Read the paper to learn how we're revolutionizing AI agent memory.
Build an AI system that combines CrewAI’s agent-based architecture with Zentry’s memory capabilities. This integration enables persistent memory across agent interactions and personalized task execution based on user history.

​
Overview

In this guide, we’ll create a CrewAI agent that:
  1. Uses CrewAI to manage AI agents and tasks
  2. Leverages Zentry to store and retrieve conversation history
  3. Creates personalized experiences based on stored user preferences

​
Setup and Configuration

Install necessary libraries: 
pip install crewai crewai-tools Zentryai
Import required modules and set up configurations:
Remember to get your API keys from Zentry Platform, OpenAI and Serper Dev for search capabilities.
import os
from Zentry import MemoryClient
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool

# Configuration
os.environ["Zentry_API_KEY"] = "your-Zentry-api-key"
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
os.environ["SERPER_API_KEY"] = "your-serper-api-key"

# Initialize Zentry client
client = MemoryClient()

​
Store User Preferences

Set up initial conversation and preferences storage: 
def store_user_preferences(user_id: str, conversation: list):
    """Store user preferences from conversation history"""
    client.add(conversation, user_id=user_id)

# Example conversation storage
messages = [
    {
        "role": "user",
        "content": "Hi there! I'm planning a vacation and could use some advice.",
    },
    {
        "role": "assistant",
        "content": "Hello! I'd be happy to help with your vacation planning. What kind of destination do you prefer?",
    },
    {"role": "user", "content": "I am more of a beach person than a mountain person."},
    {
        "role": "assistant",
        "content": "That's interesting. Do you like hotels or airbnb?",
    },
    {"role": "user", "content": "I like airbnb more."},
]

store_user_preferences("crew_user_1", messages)

​
Create CrewAI Agent

Define an agent with memory capabilities: 
def create_travel_agent():
    """Create a travel planning agent with search capabilities"""
    search_tool = SerperDevTool()

    return Agent(
        role="Personalized Travel Planner Agent",
        goal="Plan personalized travel itineraries",
        backstory="""You are a seasoned travel planner, known for your meticulous attention to detail.""",
        allow_delegation=False,
        memory=True,
        tools=[search_tool],
    )

​
Define Tasks

Create tasks for your agent: 
def create_planning_task(agent, destination: str):
    """Create a travel planning task"""
    return Task(
        description=f"""Find places to live, eat, and visit in {destination}.""",
        expected_output=f"A detailed list of places to live, eat, and visit in {destination}.",
        agent=agent,
    )

​
Set Up Crew

Configure the crew with memory integration: 
def setup_crew(agents: list, tasks: list):
    """Set up a crew with Zentry memory integration"""
    return Crew(
        agents=agents,
        tasks=tasks,
        process=Process.sequential,
        memory=True,
        memory_config={
            "provider": "Zentry",
            "config": {"user_id": "crew_user_1"},
        }
    )

​
Main Execution Function

Implement the main function to run the travel planning system: 
def plan_trip(destination: str, user_id: str):
    # Create agent
    travel_agent = create_travel_agent()

    # Create task
    planning_task = create_planning_task(travel_agent, destination)

    # Setup crew
    crew = setup_crew([travel_agent], [planning_task])

    # Execute and return results
    return crew.kickoff()

# Example usage
if __name__ == "__main__":
    result = plan_trip("San Francisco", "crew_user_1")
    print(result)

​
Key Features

  1. Persistent Memory: Uses Zentry to maintain user preferences and conversation history
  2. Agent-Based Architecture: Leverages CrewAI’s agent system for task execution
  3. Search Integration: Includes SerperDev tool for real-world information retrieval
  4. Personalization: Utilizes stored preferences for tailored recommendations

​
Benefits

  1. Persistent Context & Memory: Maintains user preferences and interaction history across sessions
  2. Flexible & Scalable Design: Easily extendable with new agents, tasks and capabilities

​
Conclusion

By combining CrewAI with Zentry, you can create sophisticated AI systems that maintain context and provide personalized experiences while leveraging the power of autonomous agents.

​
Help

Telegram

Join our community

GitHub

Ask questions on GitHub

Support

Talk to founders