Lyzr Cognis + CrewAI

pip install lyzr-adk crewai crewai-tools

export LYZR_API_KEY="your-lyzr-api-key"
export OPENAI_API_KEY="your-openai-api-key"

from lyzr import Cognis, CognisMessage
from crewai import Agent, Task, Crew

cog = Cognis()

# 1. Retrieve user preferences from Cognis
memories = cog.search(query="travel preferences", owner_id="user_123", limit=5)
memory_context = "\n".join(f"- {m.content}" for m in memories)

# 2. Inject memories into agent backstory
agent = Agent(
    role="Travel Researcher",
    goal="Find the best travel options",
    backstory=f"You know this about the user:\n{memory_context}",
)

# 3. Run the crew
task = Task(description="Research beach destinations", expected_output="Top 3 destinations", agent=agent)
crew = Crew(agents=[agent], tasks=[task])
result = crew.kickoff()

# 4. Store the result in Cognis
cog.add(
    messages=[
        CognisMessage(role="user", content="Plan a beach vacation"),
        CognisMessage(role="assistant", content=str(result)),
    ],
    owner_id="user_123",
    agent_id="travel_crew",
)

import os
from crewai import Agent, Task, Crew, Process
from lyzr import Cognis, CognisMessage

cog = Cognis(api_key=os.getenv("LYZR_API_KEY"))
OWNER_ID = "traveler_007"
AGENT_ID = "travel_crew"


def get_memory_context(query: str, owner_id: str) -> str:
    """Retrieve relevant memories and format for agent backstory."""
    results = cog.search(query=query, owner_id=owner_id, limit=5)
    if not results:
        return "No prior preferences known."
    return "\n".join(f"- {r.content}" for r in results)


def store_crew_result(user_request: str, crew_output: str, owner_id: str):
    """Persist the planning request and result in Cognis."""
    cog.add(
        messages=[
            CognisMessage(role="user", content=user_request),
            CognisMessage(role="assistant", content=crew_output),
        ],
        owner_id=owner_id,
        agent_id=AGENT_ID,
    )

def plan_trip(destination: str, owner_id: str = OWNER_ID) -> str:
    # 1. Retrieve user preferences
    memory_context = get_memory_context(
        query=f"travel preferences for {destination}",
        owner_id=owner_id,
    )

    # 2. Create agents with memory-enriched backstories
    researcher = Agent(
        role="Travel Researcher",
        goal=f"Find the best travel options for {destination}",
        backstory=(
            "You are an expert travel researcher. Consider the traveler's "
            f"known preferences:\n{memory_context}"
        ),
        verbose=True,
    )

    planner = Agent(
        role="Trip Planner",
        goal=f"Create a detailed itinerary for {destination}",
        backstory=(
            "You create personalized itineraries. You know this about "
            f"the traveler:\n{memory_context}"
        ),
        verbose=True,
    )

    # 3. Define tasks
    research_task = Task(
        description=f"Research top attractions, restaurants, and activities in {destination}.",
        expected_output="Recommended attractions, restaurants, and activities with descriptions.",
        agent=researcher,
    )

    planning_task = Task(
        description=f"Create a 3-day itinerary for {destination} with morning, afternoon, and evening activities.",
        expected_output="A detailed 3-day itinerary with times, locations, and tips.",
        agent=planner,
    )

    # 4. Run the crew
    crew = Crew(
        agents=[researcher, planner],
        tasks=[research_task, planning_task],
        process=Process.sequential,
        verbose=True,
    )
    result = crew.kickoff()
    crew_output = str(result)

    # 5. Store results in Cognis
    store_crew_result(f"Plan a trip to {destination}", crew_output, owner_id)

    return crew_output

# Seed user preferences
cog.add(
    messages=[
        CognisMessage(
            role="user",
            content="I love beach destinations and seafood. I prefer boutique hotels.",
        ),
        CognisMessage(
            role="assistant",
            content="Noted! You prefer beaches, seafood, and boutique hotels.",
        ),
    ],
    owner_id=OWNER_ID,
    agent_id=AGENT_ID,
)

# First trip — agents receive preferences via backstory
result1 = plan_trip("Bali, Indonesia")

# Second trip — agents also see the Bali trip in their memory
result2 = plan_trip("Lisbon, Portugal")

from crewai.tools import tool

@tool("Search User Memory")
def search_user_memory(query: str) -> str:
    """Search the user's memory for relevant information."""
    results = cog.search(query=query, owner_id=OWNER_ID, limit=5)
    if not results:
        return "No relevant memories found."
    return "\n".join(f"- {r.content}" for r in results)

researcher = Agent(
    role="Travel Researcher",
    tools=[search_user_memory],
    # ...
)

results = cog.search(
    query="travel history and preferences",
    owner_id=OWNER_ID,
    cross_session=True,
    limit=10,
)

cog.add(
    messages=[
        CognisMessage(role="user", content="Plan a trip to Bali"),
        CognisMessage(role="assistant", content=str(result)),
    ],
    owner_id=OWNER_ID,
    agent_id="travel_crew",
    session_id="trip_bali_2024",
)