import asyncio

from reme import ReMeFb


async def main():
    # Initialize and start
    reme = ReMeFb(
        default_llm_config={
            "backend": "openai",  # Backend type, OpenAI-compatible API
            "model_name": "qwen3.5-plus",  # Model name
        },
        default_file_store_config={
            "backend": "chroma",  # Store backend: sqlite/chroma/local
            "fts_enabled": True,  # Enable full-text search
            "vector_enabled": False,  # Enable vector search (set False if no embedding service)
        },
        context_window_tokens=128000,  # Model context window size (tokens)
        reserve_tokens=36000,  # Tokens reserved for output
        keep_recent_tokens=20000,  # Tokens to keep for recent messages
        vector_weight=0.7,  # Vector search weight (0–1) for hybrid search
        candidate_multiplier=3.0,  # Candidate multiplier for recall
    )
    await reme.start()

    messages = [
        {"role": "user", "content": "I prefer Python 3.12"},
        {"role": "assistant", "content": "Noted, you prefer Python 3.12"},
    ]

    # Check if context exceeds limit
    result = await reme.context_check(messages)
    print(f"Compact result: {result}")

    # Compact conversation to summary
    summary = await reme.compact(messages_to_summarize=messages)
    print(f"Summary: {summary}")

    # Write important memory to files (ReAct Agent does this automatically)
    await reme.summary(messages=messages, date="2026-02-28")

    # Semantic search over memory
    results = await reme.memory_search(query="Python version preference", max_results=5)
    print(f"Search results: {results}")

    # Read specified memory file
    content = await reme.memory_get(path="MEMORY.md")
    print(f"Memory content: {content}")

    # Close (save embedding cache, stop file watcher)
    await reme.close()


if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from reme import ReMe


async def main():
    # Initialize ReMe
    reme = ReMe(
        working_dir=".reme",
        default_llm_config={
            "backend": "openai",
            "model_name": "qwen3-30b-a3b-thinking-2507",
        },
        default_embedding_model_config={
            "backend": "openai",
            "model_name": "text-embedding-v4",
            "dimensions": 1024,
        },
        default_vector_store_config={
            "backend": "local",  # Supports local/chroma/qdrant/elasticsearch
        },
    )
    await reme.start()

    messages = [
        {"role": "user", "content": "Help me write a Python script", "time_created": "2026-02-28 10:00:00"},
        {"role": "assistant", "content": "Sure, I'll help you write it", "time_created": "2026-02-28 10:00:05"},
    ]

    # 1. Summarize memory from conversation (auto-extract user preferences, task experience, etc.)
    result = await reme.summarize_memory(
        messages=messages,
        user_name="alice",  # Personal memory
        # task_name="code_writing",  # Task memory
    )
    print(f"Summarize result: {result}")

    # 2. Retrieve relevant memory
    memories = await reme.retrieve_memory(
        query="Python programming",
        # user_name="alice",
    )
    print(f"Retrieve result: {memories}")

    # 3. Manually add memory
    memory_node = await reme.add_memory(
        memory_content="User prefers concise code style",
        user_name="alice",
    )
    print(f"Added memory: {memory_node}")
    memory_id = memory_node.memory_id

    # 4. Get single memory by ID
    fetched_memory = await reme.get_memory(memory_id=memory_id)
    print(f"Fetched memory: {fetched_memory}")

    # 5. Update memory content
    updated_memory = await reme.update_memory(
        memory_id=memory_id,
        user_name="alice",
        memory_content="User prefers concise, well-commented code style",
    )
    print(f"Updated memory: {updated_memory}")

    # 6. List all memories for user (with filtering and sorting)
    all_memories = await reme.list_memory(
        user_name="alice",
        limit=10,
        sort_key="time_created",
        reverse=True,
    )
    print(f"User memory list: {all_memories}")

    # 7. Delete specified memory
    await reme.delete_memory(memory_id=memory_id)
    print(f"Deleted memory: {memory_id}")

    # 8. Delete all memories (use with caution)
    # await reme.delete_all()

    await reme.close()


if __name__ == "__main__":
    asyncio.run(main())