from agents import Agent, Tool, Runner
from memory_system import MemorySystem

# Initialize memory system
memory = MemorySystem()

# Define memory creation tool
def store_memory(content: str, memory_type: str, importance: float = 0.5, 
                 tags: list = None, user_id: str = None) -> dict:
    """Store information in the agent's memory."""
    return memory.create(
        content=content,
        memory_type=memory_type,
        importance=importance,
        tags=tags or [],
        user_id=user_id
    )

# Create tool for the agent
memory_tool = Tool(
    name="store_memory",
    description="Store important information in memory",
    function=store_memory
)

# Create agent with the tool
agent = Agent(
    name="MOOD MNKY",
    instructions="You are MOOD MNKY, the brand assistant. Remember important information about users.",
    tools=[memory_tool]
)

# Run the agent
runner = Runner()
result = await runner.run(agent, "I have sensitive skin and prefer fragrance-free products")

from agents import Agent, Tool, Runner
from memory_system import MemorySystem

# Initialize memory system
memory = MemorySystem()

# Define memory retrieval tool
def retrieve_memories(query: str, memory_type: str = None, 
                      limit: int = 5, user_id: str = None) -> list:
    """Retrieve relevant memories based on the query."""
    return memory.search(
        query=query,
        memory_type=memory_type,
        limit=limit,
        user_id=user_id
    )

# Create tool for the agent
retrieval_tool = Tool(
    name="retrieve_memories",
    description="Recall relevant information from memory",
    function=retrieve_memories
)

# Create agent with the tool
agent = Agent(
    name="MOOD MNKY",
    instructions="You are MOOD MNKY, the brand assistant. Use your memory to provide personalized assistance.",
    tools=[retrieval_tool]
)

# Run the agent
runner = Runner()
result = await runner.run(agent, "What products would you recommend for me?")

from agents import Agent, Runner
from memory_system import MemorySystem

# Initialize memory system
memory = MemorySystem()

async def create_memory_aware_agent(user_id: str) -> Agent:
    # Retrieve relevant memories for the user
    user_memories = memory.get_user_summary(user_id)
    
    # Create agent with memory-infused instructions
    agent = Agent(
        name="MOOD MNKY",
        instructions=f"""You are MOOD MNKY, the brand assistant.
        
        What you know about this user:
        {user_memories}
        
        Use this information to provide personalized assistance."""
    )
    
    return agent

# Create and run agent for a specific user
agent = await create_memory_aware_agent("usr_425b3c")
runner = Runner()
result = await runner.run(agent, "Can you recommend something new for me to try?")

from agents import Agent, Runner
from agents.mcp.server import MCPServerSse, MCPServerSseParams

# Set up MCP server for memory system
async with MCPServerSse(
    params=MCPServerSseParams(
        url="http://localhost:3000/memory-mcp",
        headers={"Authorization": f"Bearer {API_KEY}"}
    ),
    name="memory_mcp",
    cache_tools_list=True
) as memory_server:
    
    # Create agent with memory MCP server
    agent = Agent(
        name="MOOD MNKY",
        instructions="You are MOOD MNKY, the brand assistant. Use your memory to provide personalized assistance.",
        mcp_servers=[memory_server]
    )
    
    # Run the agent
    runner = Runner()
    result = await runner.run(agent, "What was that candle I liked last time?")

def retrieve_by_context(context_type: str, user_id: str) -> list:
    """Retrieve memories relevant to a specific context."""
    return memory.search(
        filters={
            "metadata.context": context_type,
            "user_id": user_id
        },
        sort_by="importance",
        limit=10
    )

product_memories = retrieve_by_context("product_recommendation", "usr_425b3c")

def retrieve_similar(query: str, user_id: str) -> list:
    """Find memories semantically similar to the query."""
    # Generate embedding for query
    query_embedding = generate_embedding(query)
    
    return memory.vector_search(
        vector=query_embedding,
        user_id=user_id,
        limit=5
    )

similar_memories = retrieve_similar("What scents help with sleep?", "usr_425b3c")

def retrieve_recent(memory_type: str, user_id: str, days: int = 7) -> list:
    """Retrieve recent memories of a specific type."""
    cutoff_date = datetime.now() - timedelta(days=days)
    
    return memory.search(
        filters={
            "memory_type": memory_type,
            "user_id": user_id,
            "created_at": {"$gte": cutoff_date}
        },
        sort_by="created_at",
        sort_order="desc",
        limit=20
    )

recent_interactions = retrieve_recent("short_term", "usr_425b3c", 3)