from mesh import MemoryManager, Agent

# Create a memory manager with filtering enabled
memory_manager = MemoryManager(
    max_memory_size=1000,
    filter_threshold=0.3,
    cleanup_interval=60  # seconds
)

# Create an agent with Mesh memory management
agent = Agent(
    name="assistant",
    memory_manager=memory_manager
)

# Add memories - Mesh will automatically filter obsolete ones
agent.remember("User prefers morning meetings")
agent.remember("Project deadline is next Friday")
agent.remember("Temporary note: coffee machine broken")  # Will be filtered out

# Retrieve relevant memories
relevant_memories = agent.recall("meeting preferences")
print(relevant_memories)

from mesh import SharedMemoryNetwork, Agent

# Create a shared memory network
network = SharedMemoryNetwork()

# Create agents that share memory
agent1 = Agent("researcher", network=network)
agent2 = Agent("analyst", network=network)

# Agent1 learns something important
agent1.remember("Market trend: AI adoption increasing 40% YoY", importance=0.9)

# Agent2 can access this shared memory
shared_knowledge = agent2.recall("market trends")
print(f"Agent2 knows: {shared_knowledge}")

from mesh import MemoryManager, FilterPolicy, SharingPolicy

# Custom memory filtering policy
filter_policy = FilterPolicy(
    time_decay=0.1,          # How quickly memories fade
    relevance_threshold=0.4,  # Minimum relevance to keep
    max_age_days=30,         # Maximum age before auto-deletion
    preserve_keywords=["important", "critical", "remember"]
)

# Custom sharing policy
sharing_policy = SharingPolicy(
    share_threshold=0.6,     # Minimum importance to share
    network_scope="global",  # Share across all agents
    encryption=True          # Encrypt shared memories
)

# Create advanced memory manager
memory_manager = MemoryManager(
    filter_policy=filter_policy,
    sharing_policy=sharing_policy,
    analytics=True  # Enable memory analytics
)

from mesh import MeshLangChainMemory
from langchain.agents import create_react_agent

# Create Mesh-powered LangChain memory
mesh_memory = MeshLangChainMemory(
    filter_enabled=True,
    sharing_enabled=True
)

# Use with LangChain agent
agent = create_react_agent(
    llm=your_llm,
    tools=your_tools,
    memory=mesh_memory
)

from mesh import MeshOpenAIMemory
import openai

# Create OpenAI client with Mesh memory
mesh_memory = MeshOpenAIMemory(agent_id="assistant-1")

# Your OpenAI assistant calls
def process_conversation(messages):
    # Mesh automatically filters and manages memory
    relevant_context = mesh_memory.get_relevant_context(messages)
    
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=relevant_context + messages
    )
    
    # Store important information
    mesh_memory.store_interaction(messages, response)
    return response

from mesh import MemoryAnalytics

analytics = MemoryAnalytics(memory_manager)

# Get memory statistics
stats = analytics.get_stats()
print(f"Memory utilization: {stats.utilization}%")
print(f"Filtered memories: {stats.filtered_count}")
print(f"Shared memories: {stats.shared_count}")

# Visualize memory trends
analytics.plot_memory_trends()